File: Mathlib/CategoryTheory/Limits/Fubini.lean

full_name: CategoryTheory.Limits.DiagramOfCones.obj
code: /-- A structure carrying a diagram of cones over the functors `F.obj j`.
-/
structure DiagramOfCones where
  /-- For each object, a cone. -/
  obj : ∀ j : J, Cone (F.obj j)
  /-- For each map, a map of cones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: CategoryTheory.Limits.Cone (F.obj j)

full_name: CategoryTheory.Limits.DiagramOfCones.id
code: /-- A structure carrying a diagram of cones over the functors `F.obj j`.
-/
structure DiagramOfCones where
  /-- For each object, a cone. -/
  obj : ∀ j : J, Cone (F.obj j)
  /-- For each map, a map of cones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: (self.map (𝟙 j)).hom = 𝟙 ((CategoryTheory.Limits.Cones.postcompose (F.map (𝟙 j))).obj (self.obj j)).pt

full_name: CategoryTheory.Limits.DiagramOfCones.map
code: /-- A structure carrying a diagram of cones over the functors `F.obj j`.
-/
structure DiagramOfCones where
  /-- For each object, a cone. -/
  obj : ∀ j : J, Cone (F.obj j)
  /-- For each map, a map of cones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: (CategoryTheory.Limits.Cones.postcompose (F.map f)).obj (self.obj j) ⟶ self.obj j'

full_name: CategoryTheory.Limits.DiagramOfCones.comp
code: /-- A structure carrying a diagram of cones over the functors `F.obj j`.
-/
structure DiagramOfCones where
  /-- For each object, a cone. -/
  obj : ∀ j : J, Cone (F.obj j)
  /-- For each map, a map of cones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: (self.map (f ≫ g)).hom = (self.map f).hom ≫ (self.map g).hom

full_name: CategoryTheory.Limits.DiagramOfCones
code: /-- A structure carrying a diagram of cones over the functors `F.obj j`.
-/
structure DiagramOfCones where
  /-- For each object, a cone. -/
  obj : ∀ j : J, Cone (F.obj j)
  /-- For each map, a map of cones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (Cones.postcompose (F.map f)).obj (obj j) ⟶ obj j'
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.Limits.DiagramOfCocones.map
code: /-- A structure carrying a diagram of cocones over the functors `F.obj j`.
-/
structure DiagramOfCocones where
  /-- For each object, a cocone. -/
  obj : ∀ j : J, Cocone (F.obj j)
  /-- For each map, a map of cocones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: self.obj j ⟶ (CategoryTheory.Limits.Cocones.precompose (F.map f)).obj (self.obj j')

full_name: CategoryTheory.Limits.DiagramOfCocones.comp
code: /-- A structure carrying a diagram of cocones over the functors `F.obj j`.
-/
structure DiagramOfCocones where
  /-- For each object, a cocone. -/
  obj : ∀ j : J, Cocone (F.obj j)
  /-- For each map, a map of cocones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: (self.map (f ≫ g)).hom = (self.map f).hom ≫ (self.map g).hom

full_name: CategoryTheory.Limits.DiagramOfCocones
code: /-- A structure carrying a diagram of cocones over the functors `F.obj j`.
-/
structure DiagramOfCocones where
  /-- For each object, a cocone. -/
  obj : ∀ j : J, Cocone (F.obj j)
  /-- For each map, a map of cocones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.Limits.DiagramOfCocones.obj
code: /-- A structure carrying a diagram of cocones over the functors `F.obj j`.
-/
structure DiagramOfCocones where
  /-- For each object, a cocone. -/
  obj : ∀ j : J, Cocone (F.obj j)
  /-- For each map, a map of cocones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: CategoryTheory.Limits.Cocone (F.obj j)

full_name: CategoryTheory.Limits.DiagramOfCocones.id
code: /-- A structure carrying a diagram of cocones over the functors `F.obj j`.
-/
structure DiagramOfCocones where
  /-- For each object, a cocone. -/
  obj : ∀ j : J, Cocone (F.obj j)
  /-- For each map, a map of cocones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
goal: (self.map (𝟙 j)).hom = 𝟙 (self.obj j).pt

full_name: CategoryTheory.Limits.DiagramOfCones.conePoints
code: /-- Extract the functor `J ⥤ C` consisting of the cone points and the maps between them,
from a `DiagramOfCones`.
-/
@[simps]
def DiagramOfCones.conePoints (D : DiagramOfCones F) : J ⥤ C 
goal: J ⥤ C

full_name: CategoryTheory.Limits.DiagramOfCones.conePoints_map
code: /-- Extract the functor `J ⥤ C` consisting of the cone points and the maps between them,
from a `DiagramOfCones`.
-/
@[simps]
def DiagramOfCones.conePoints (D : DiagramOfCones F) : J ⥤ C 
goal: ∀ {X Y : J} (f : X ⟶ Y), D.conePoints.map f = (D.map f).hom

full_name: CategoryTheory.Limits.DiagramOfCones.conePoints_obj
code: /-- Extract the functor `J ⥤ C` consisting of the cone points and the maps between them,
from a `DiagramOfCones`.
-/
@[simps]
def DiagramOfCones.conePoints (D : DiagramOfCones F) : J ⥤ C 
goal: D.conePoints.obj j = (D.obj j).pt

full_name: CategoryTheory.Limits.DiagramOfCocones.coconePoints_obj
code: /-- Extract the functor `J ⥤ C` consisting of the cocone points and the maps between them,
from a `DiagramOfCocones`.
-/
@[simps]
def DiagramOfCocones.coconePoints (D : DiagramOfCocones F) : J ⥤ C 
goal: D.coconePoints.obj j = (D.obj j).pt

full_name: CategoryTheory.Limits.DiagramOfCocones.coconePoints
code: /-- Extract the functor `J ⥤ C` consisting of the cocone points and the maps between them,
from a `DiagramOfCocones`.
-/
@[simps]
def DiagramOfCocones.coconePoints (D : DiagramOfCocones F) : J ⥤ C 
goal: J ⥤ C

full_name: CategoryTheory.Limits.DiagramOfCocones.coconePoints_map
code: /-- Extract the functor `J ⥤ C` consisting of the cocone points and the maps between them,
from a `DiagramOfCocones`.
-/
@[simps]
def DiagramOfCocones.coconePoints (D : DiagramOfCocones F) : J ⥤ C 
goal: ∀ {X Y : J} (f : X ⟶ Y), D.coconePoints.map f = (D.map f).hom

full_name: CategoryTheory.Limits.coneOfConeUncurry_pt
code: /-- Given a diagram `D` of limit cones over the `F.obj j`, and a cone over `uncurry.obj F`,
we can construct a cone over the diagram consisting of the cone points from `D`.
-/
@[simps]
def coneOfConeUncurry {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    (c : Cone (uncurry.obj F)) : Cone D.conePoints 
goal: (CategoryTheory.Limits.coneOfConeUncurry Q c).pt = c.pt

full_name: CategoryTheory.Limits.coneOfConeUncurry
code: /-- Given a diagram `D` of limit cones over the `F.obj j`, and a cone over `uncurry.obj F`,
we can construct a cone over the diagram consisting of the cone points from `D`.
-/
@[simps]
def coneOfConeUncurry {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    (c : Cone (uncurry.obj F)) : Cone D.conePoints 
goal: CategoryTheory.Limits.Cone D.conePoints

full_name: CategoryTheory.Limits.coneOfConeUncurry_π_app
code: /-- Given a diagram `D` of limit cones over the `F.obj j`, and a cone over `uncurry.obj F`,
we can construct a cone over the diagram consisting of the cone points from `D`.
-/
@[simps]
def coneOfConeUncurry {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    (c : Cone (uncurry.obj F)) : Cone D.conePoints 
goal: (CategoryTheory.Limits.coneOfConeUncurry Q c).π.app j =
  (Q j).lift { pt := c.pt, π := { app := fun k => c.π.app (j, k), naturality := ⋯ } }

full_name: CategoryTheory.Limits.coconeOfCoconeUncurry
code: /-- Given a diagram `D` of colimit cocones over the `F.obj j`, and a cocone over `uncurry.obj F`,
we can construct a cocone over the diagram consisting of the cocone points from `D`.
-/
@[simps]
def coconeOfCoconeUncurry {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    (c : Cocone (uncurry.obj F)) : Cocone D.coconePoints 
goal: CategoryTheory.Limits.Cocone D.coconePoints

full_name: CategoryTheory.Limits.coconeOfCoconeUncurry_pt
code: /-- Given a diagram `D` of colimit cocones over the `F.obj j`, and a cocone over `uncurry.obj F`,
we can construct a cocone over the diagram consisting of the cocone points from `D`.
-/
@[simps]
def coconeOfCoconeUncurry {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    (c : Cocone (uncurry.obj F)) : Cocone D.coconePoints 
goal: (CategoryTheory.Limits.coconeOfCoconeUncurry Q c).pt = c.pt

full_name: CategoryTheory.Limits.coconeOfCoconeUncurry_ι_app
code: /-- Given a diagram `D` of colimit cocones over the `F.obj j`, and a cocone over `uncurry.obj F`,
we can construct a cocone over the diagram consisting of the cocone points from `D`.
-/
@[simps]
def coconeOfCoconeUncurry {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    (c : Cocone (uncurry.obj F)) : Cocone D.coconePoints 
goal: (CategoryTheory.Limits.coconeOfCoconeUncurry Q c).ι.app j =
  (Q j).desc { pt := c.pt, ι := { app := fun k => c.ι.app (j, k), naturality := ⋯ } }

full_name: CategoryTheory.Limits.coneOfConeUncurryIsLimit
code: /-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfConeUncurry Q c)

full_name: CategoryTheory.Limits.coconeOfCoconeUncurryIsColimit
code: /-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeOfCoconeUncurry Q c)

full_name: CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits_obj
code: /-- Given a functor `F : J ⥤ K ⥤ C`, with all needed limits,
we can construct a diagram consisting of the limit cone over each functor `F.obj j`,
and the universal cone morphisms between these.
-/
@[simps]
noncomputable def DiagramOfCones.mkOfHasLimits : DiagramOfCones F 
goal: (CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits F).obj j = CategoryTheory.Limits.limit.cone (F.obj j)

full_name: CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits_map_hom
code: /-- Given a functor `F : J ⥤ K ⥤ C`, with all needed limits,
we can construct a diagram consisting of the limit cone over each functor `F.obj j`,
and the universal cone morphisms between these.
-/
@[simps]
noncomputable def DiagramOfCones.mkOfHasLimits : DiagramOfCones F 
goal: ∀ {j j' : J} (f : j ⟶ j'),
  ((CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits F).map f).hom = CategoryTheory.Limits.lim.map (F.map f)

full_name: CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits
code: /-- Given a functor `F : J ⥤ K ⥤ C`, with all needed limits,
we can construct a diagram consisting of the limit cone over each functor `F.obj j`,
and the universal cone morphisms between these.
-/
@[simps]
noncomputable def DiagramOfCones.mkOfHasLimits : DiagramOfCones F 
goal: CategoryTheory.Limits.DiagramOfCones F

full_name: CategoryTheory.Limits.diagramOfConesInhabited
code: noncomputable instance diagramOfConesInhabited : Inhabited (DiagramOfCones F) 
goal: Inhabited (CategoryTheory.Limits.DiagramOfCones F)

full_name: CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits_conePoints
code: @[simp]
theorem DiagramOfCones.mkOfHasLimits_conePoints :
    (DiagramOfCones.mkOfHasLimits F).conePoints = F ⋙ lim 
goal: (CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits F).conePoints = F ⋙ CategoryTheory.Limits.lim

full_name: CategoryTheory.Limits.limitUncurryIsoLimitCompLim
code: /-- The Fubini theorem for a functor `F : J ⥤ K ⥤ C`,
showing that the limit of `uncurry.obj F` can be computed as
the limit of the limits of the functors `F.obj j`.
-/
noncomputable def limitUncurryIsoLimitCompLim : limit (uncurry.obj F) ≅ limit (F ⋙ lim) 
goal: CategoryTheory.Limits.limit (CategoryTheory.uncurry.obj F) ≅ CategoryTheory.Limits.limit (F ⋙ CategoryTheory.Limits.lim)

full_name: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_hom_π_π
code: @[simp, reassoc]
theorem limitUncurryIsoLimitCompLim_hom_π_π {j} {k} :
    (limitUncurryIsoLimitCompLim F).hom ≫ limit.π _ j ≫ limit.π _ k = limit.π _ (j, k) 
goal: (CategoryTheory.Limits.limitUncurryIsoLimitCompLim F).hom ≫
    CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k =
  CategoryTheory.Limits.limit.π (CategoryTheory.uncurry.obj F) (j, k)

full_name: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_inv_π
code: @[simp, reassoc]
theorem limitUncurryIsoLimitCompLim_inv_π {j} {k} :
    (limitUncurryIsoLimitCompLim F).inv ≫ limit.π _ (j, k) =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
goal: (CategoryTheory.Limits.limitUncurryIsoLimitCompLim F).inv ≫
    CategoryTheory.Limits.limit.π (CategoryTheory.uncurry.obj F) (j, k) =
  CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k

full_name: CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits_map_hom
code: /-- Given a functor `F : J ⥤ K ⥤ C`, with all needed colimits,
we can construct a diagram consisting of the colimit cocone over each functor `F.obj j`,
and the universal cocone morphisms between these.
-/
@[simps]
noncomputable def DiagramOfCocones.mkOfHasColimits : DiagramOfCocones F 
goal: ∀ {j j' : J} (f : j ⟶ j'),
  ((CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits F).map f).hom = CategoryTheory.Limits.colim.map (F.map f)

full_name: CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits_obj
code: /-- Given a functor `F : J ⥤ K ⥤ C`, with all needed colimits,
we can construct a diagram consisting of the colimit cocone over each functor `F.obj j`,
and the universal cocone morphisms between these.
-/
@[simps]
noncomputable def DiagramOfCocones.mkOfHasColimits : DiagramOfCocones F 
goal: (CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits F).obj j = CategoryTheory.Limits.colimit.cocone (F.obj j)

full_name: CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits
code: /-- Given a functor `F : J ⥤ K ⥤ C`, with all needed colimits,
we can construct a diagram consisting of the colimit cocone over each functor `F.obj j`,
and the universal cocone morphisms between these.
-/
@[simps]
noncomputable def DiagramOfCocones.mkOfHasColimits : DiagramOfCocones F 
goal: CategoryTheory.Limits.DiagramOfCocones F

full_name: CategoryTheory.Limits.diagramOfCoconesInhabited
code: noncomputable instance diagramOfCoconesInhabited : Inhabited (DiagramOfCocones F) 
goal: Inhabited (CategoryTheory.Limits.DiagramOfCocones F)

full_name: CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits_coconePoints
code: @[simp]
theorem DiagramOfCocones.mkOfHasColimits_coconePoints :
    (DiagramOfCocones.mkOfHasColimits F).coconePoints = F ⋙ colim 
goal: (CategoryTheory.Limits.DiagramOfCocones.mkOfHasColimits F).coconePoints = F ⋙ CategoryTheory.Limits.colim

full_name: CategoryTheory.Limits.colimitUncurryIsoColimitCompColim
code: /-- The Fubini theorem for a functor `F : J ⥤ K ⥤ C`,
showing that the colimit of `uncurry.obj F` can be computed as
the colimit of the colimits of the functors `F.obj j`.
-/
noncomputable def colimitUncurryIsoColimitCompColim :
    colimit (uncurry.obj F) ≅ colimit (F ⋙ colim) 
goal: CategoryTheory.Limits.colimit (CategoryTheory.uncurry.obj F) ≅
  CategoryTheory.Limits.colimit (F ⋙ CategoryTheory.Limits.colim)

full_name: CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_ι_inv
code: @[simp, reassoc]
theorem colimitUncurryIsoColimitCompColim_ι_ι_inv {j} {k} :
    colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j ≫ (colimitUncurryIsoColimitCompColim F).inv =
      colimit.ι (uncurry.obj F) (j, k) 
goal: CategoryTheory.Limits.colimit.ι (F.obj j) k ≫
    CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitUncurryIsoColimitCompColim F).inv =
  CategoryTheory.Limits.colimit.ι (CategoryTheory.uncurry.obj F) (j, k)

full_name: CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_hom
code: @[simp, reassoc]
theorem colimitUncurryIsoColimitCompColim_ι_hom {j} {k} :
    colimit.ι _ (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom =
      (colimit.ι _ k ≫ colimit.ι (F ⋙ colim) j : _ ⟶ (colimit (F ⋙ colim))) 
goal: CategoryTheory.Limits.colimit.ι (CategoryTheory.uncurry.obj F) (j, k) ≫
    (CategoryTheory.Limits.colimitUncurryIsoColimitCompColim F).hom =
  CategoryTheory.Limits.colimit.ι (F.obj j) k ≫ CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j

full_name: CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim
code: /-- The limit of `F.flip ⋙ lim` is isomorphic to the limit of `F ⋙ lim`. -/
noncomputable def limitFlipCompLimIsoLimitCompLim : limit (F.flip ⋙ lim) ≅ limit (F ⋙ lim) 
goal: CategoryTheory.Limits.limit (F.flip ⋙ CategoryTheory.Limits.lim) ≅
  CategoryTheory.Limits.limit (F ⋙ CategoryTheory.Limits.lim)

full_name: CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_hom_π_π
code: @[simp, reassoc]
theorem limitFlipCompLimIsoLimitCompLim_hom_π_π (j) (k) :
    (limitFlipCompLimIsoLimitCompLim F).hom ≫ limit.π _ j ≫ limit.π _ k =
      (limit.π _ k ≫ limit.π _ j : limit (_ ⋙ lim) ⟶ _) 
goal: (CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim F).hom ≫
    CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k =
  CategoryTheory.Limits.limit.π (F.flip ⋙ CategoryTheory.Limits.lim) k ≫ CategoryTheory.Limits.limit.π (F.flip.obj k) j

full_name: CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_inv_π_π
code: @[simp, reassoc]
theorem limitFlipCompLimIsoLimitCompLim_inv_π_π (k) (j) :
    (limitFlipCompLimIsoLimitCompLim F).inv ≫ limit.π _ k ≫ limit.π _ j =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
goal: (CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim F).inv ≫
    CategoryTheory.Limits.limit.π (F.flip ⋙ CategoryTheory.Limits.lim) k ≫
      CategoryTheory.Limits.limit.π (F.flip.obj k) j =
  CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.Limits.lim) j ≫ CategoryTheory.Limits.limit.π (F.obj j) k

full_name: CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim
code: /-- The colimit of `F.flip ⋙ colim` is isomorphic to the colimit of `F ⋙ colim`. -/
noncomputable def colimitFlipCompColimIsoColimitCompColim :
    colimit (F.flip ⋙ colim) ≅ colimit (F ⋙ colim) 
goal: CategoryTheory.Limits.colimit (F.flip ⋙ CategoryTheory.Limits.colim) ≅
  CategoryTheory.Limits.colimit (F ⋙ CategoryTheory.Limits.colim)

full_name: CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim_ι_ι_hom
code: @[simp, reassoc]
theorem colimitFlipCompColimIsoColimitCompColim_ι_ι_hom (j) (k) :
    colimit.ι (F.flip.obj k) j ≫ colimit.ι (F.flip ⋙ colim) k ≫
      (colimitFlipCompColimIsoColimitCompColim F).hom =
        (colimit.ι _ k ≫ colimit.ι (F ⋙ colim) j : _ ⟶ colimit (F⋙ colim)) 
goal: CategoryTheory.Limits.colimit.ι (F.flip.obj k) j ≫
    CategoryTheory.Limits.colimit.ι (F.flip ⋙ CategoryTheory.Limits.colim) k ≫
      (CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim F).hom =
  CategoryTheory.Limits.colimit.ι (F.obj j) k ≫ CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j

full_name: CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim_ι_ι_inv
code: @[simp, reassoc]
theorem colimitFlipCompColimIsoColimitCompColim_ι_ι_inv (k) (j) :
    colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j ≫
      (colimitFlipCompColimIsoColimitCompColim F).inv =
        (colimit.ι _ j ≫ colimit.ι (F.flip ⋙ colim) k : _ ⟶ colimit (F.flip ⋙ colim)) 
goal: CategoryTheory.Limits.colimit.ι (F.obj j) k ≫
    CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim F).inv =
  CategoryTheory.Limits.colimit.ι (F.flip.obj k) j ≫
    CategoryTheory.Limits.colimit.ι (F.flip ⋙ CategoryTheory.Limits.colim) k

full_name: CategoryTheory.Limits.limitIsoLimitCurryCompLim
code: /-- The Fubini theorem for a functor `G : J × K ⥤ C`,
showing that the limit of `G` can be computed as
the limit of the limits of the functors `G.obj (j, _)`.
-/
noncomputable def limitIsoLimitCurryCompLim : limit G ≅ limit (curry.obj G ⋙ lim) 
goal: CategoryTheory.Limits.limit G ≅ CategoryTheory.Limits.limit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim)

full_name: CategoryTheory.Limits.limitIsoLimitCurryCompLim_hom_π_π
code: @[simp, reassoc]
theorem limitIsoLimitCurryCompLim_hom_π_π {j} {k} :
    (limitIsoLimitCurryCompLim G).hom ≫ limit.π _ j ≫ limit.π _ k = limit.π _ (j, k) 
goal: (CategoryTheory.Limits.limitIsoLimitCurryCompLim G).hom ≫
    CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
      CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k =
  CategoryTheory.Limits.limit.π G (j, k)

full_name: CategoryTheory.Limits.limitIsoLimitCurryCompLim_inv_π
code: @[simp, reassoc]
theorem limitIsoLimitCurryCompLim_inv_π {j} {k} :
    (limitIsoLimitCurryCompLim G).inv ≫ limit.π _ (j, k) =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
goal: (CategoryTheory.Limits.limitIsoLimitCurryCompLim G).inv ≫ CategoryTheory.Limits.limit.π G (j, k) =
  CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k

full_name: CategoryTheory.Limits.colimitIsoColimitCurryCompColim
code: /-- The Fubini theorem for a functor `G : J × K ⥤ C`,
showing that the colimit of `G` can be computed as
the colimit of the colimits of the functors `G.obj (j, _)`.
-/
noncomputable def colimitIsoColimitCurryCompColim : colimit G ≅ colimit (curry.obj G ⋙ colim) 
goal: CategoryTheory.Limits.colimit G ≅
  CategoryTheory.Limits.colimit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim)

full_name: CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_ι_inv
code: @[simp, reassoc]
theorem colimitIsoColimitCurryCompColim_ι_ι_inv {j} {k} :
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j ≫
      (colimitIsoColimitCurryCompColim G).inv  = colimit.ι _ (j, k) 
goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitIsoColimitCurryCompColim G).inv =
  CategoryTheory.Limits.colimit.ι G (j, k)

full_name: CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_hom
code: @[simp, reassoc]
theorem colimitIsoColimitCurryCompColim_ι_hom {j} {k} :
    colimit.ι _ (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom =
      (colimit.ι (_) k ≫ colimit.ι (curry.obj G ⋙ colim) j : _ ⟶ colimit (_ ⋙ colim)) 
goal: CategoryTheory.Limits.colimit.ι G (j, k) ≫ (CategoryTheory.Limits.colimitIsoColimitCurryCompColim G).hom =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j

full_name: CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim
code: /-- A variant of the Fubini theorem for a functor `G : J × K ⥤ C`,
showing that $\lim_k \lim_j G(j,k) ≅ \lim_j \lim_k G(j,k)$.
-/
noncomputable def limitCurrySwapCompLimIsoLimitCurryCompLim :
    limit (curry.obj (Prod.swap K J ⋙ G) ⋙ lim) ≅ limit (curry.obj G ⋙ lim) 
goal: CategoryTheory.Limits.limit (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.lim) ≅
  CategoryTheory.Limits.limit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim)

full_name: CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim_hom_π_π
code: @[simp]
theorem limitCurrySwapCompLimIsoLimitCurryCompLim_hom_π_π {j} {k} :
    (limitCurrySwapCompLimIsoLimitCurryCompLim G).hom ≫ limit.π _ j ≫ limit.π _ k =
      (limit.π _ k ≫ limit.π _ j : limit (_ ⋙ lim) ⟶ _) 
goal: (CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim G).hom ≫
    CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
      CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k =
  CategoryTheory.Limits.limit.π
      (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.lim) k ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j

full_name: CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim_inv_π_π
code: @[simp]
theorem limitCurrySwapCompLimIsoLimitCurryCompLim_inv_π_π {j} {k} :
    (limitCurrySwapCompLimIsoLimitCurryCompLim G).inv ≫ limit.π _ k ≫ limit.π _ j =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _) 
goal: (CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim G).inv ≫
    CategoryTheory.Limits.limit.π
        (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.lim) k ≫
      CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j =
  CategoryTheory.Limits.limit.π (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.lim) j ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k

full_name: CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim
code: /-- A variant of the Fubini theorem for a functor `G : J × K ⥤ C`,
showing that $\colim_k \colim_j G(j,k) ≅ \colim_j \colim_k G(j,k)$.
-/
noncomputable def colimitCurrySwapCompColimIsoColimitCurryCompColim :
    colimit (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) ≅ colimit (curry.obj G ⋙ colim) 
goal: CategoryTheory.Limits.colimit
    (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.colim) ≅
  CategoryTheory.Limits.colimit (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim)

full_name: CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom
code: @[simp]
theorem colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom {j} {k} :
    colimit.ι _ j ≫ colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
      (colimitCurrySwapCompColimIsoColimitCurryCompColim G).hom =
        (colimit.ι _ k ≫ colimit.ι (curry.obj G ⋙ colim) j : _ ⟶ colimit (curry.obj G⋙ colim)) 
goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j ≫
    CategoryTheory.Limits.colimit.ι
        (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.colim) k ≫
      (CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim G).hom =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j

full_name: CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_inv
code: @[simp]
theorem colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_inv {j} {k} :
    colimit.ι _ k ≫ colimit.ι (curry.obj G ⋙ colim) j ≫
      (colimitCurrySwapCompColimIsoColimitCurryCompColim G).inv =
        (colimit.ι _ j ≫
          colimit.ι (curry.obj _ ⋙ colim) k :
            _ ⟶ colimit (curry.obj (Prod.swap K J ⋙ G) ⋙ colim)) 
goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim G).inv =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j ≫
    CategoryTheory.Limits.colimit.ι
      (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.colim) k