File: Mathlib/CategoryTheory/Monad/Products.lean

full_name: CategoryTheory.prodComonad_obj
code: /-- `X ⨯ -` has a comonad structure. This is sometimes called the writer comonad. -/
@[simps!]
def prodComonad : Comonad C 
goal: (CategoryTheory.prodComonad X).obj Y = (X ⨯ Y)

full_name: CategoryTheory.prodComonad
code: /-- `X ⨯ -` has a comonad structure. This is sometimes called the writer comonad. -/
@[simps!]
def prodComonad : Comonad C 
goal: CategoryTheory.Comonad C

full_name: CategoryTheory.prodComonad_map
code: /-- `X ⨯ -` has a comonad structure. This is sometimes called the writer comonad. -/
@[simps!]
def prodComonad : Comonad C 
goal: (CategoryTheory.prodComonad X).map g = CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) g

full_name: CategoryTheory.prodComonad_ε_app
code: /-- `X ⨯ -` has a comonad structure. This is sometimes called the writer comonad. -/
@[simps!]
def prodComonad : Comonad C 
goal: (CategoryTheory.prodComonad X).ε.app Y = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.prodComonad_δ_app
code: /-- `X ⨯ -` has a comonad structure. This is sometimes called the writer comonad. -/
@[simps!]
def prodComonad : Comonad C 
goal: (CategoryTheory.prodComonad X).δ.app Y =
  CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst (CategoryTheory.CategoryStruct.id (X ⨯ Y))

full_name: CategoryTheory.coalgebraToOver_obj
code: /-- The forward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def coalgebraToOver : Coalgebra (prodComonad X) ⥤ Over X 
goal: (CategoryTheory.coalgebraToOver X).obj A =
  CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.comp A.a CategoryTheory.Limits.prod.fst)

full_name: CategoryTheory.coalgebraToOver
code: /-- The forward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def coalgebraToOver : Coalgebra (prodComonad X) ⥤ Over X 
goal: CategoryTheory.Functor (CategoryTheory.prodComonad X).Coalgebra (CategoryTheory.Over X)

full_name: CategoryTheory.coalgebraToOver_map
code: /-- The forward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def coalgebraToOver : Coalgebra (prodComonad X) ⥤ Over X 
goal: ∀ {X_1 Y : (CategoryTheory.prodComonad X).Coalgebra} (f : X_1 ⟶ Y),
  (CategoryTheory.coalgebraToOver X).map f = CategoryTheory.Over.homMk f.f ⋯

full_name: CategoryTheory.overToCoalgebra_obj_a
code: /-- The backward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
goal: ((CategoryTheory.overToCoalgebra X).obj f).a =
  CategoryTheory.Limits.prod.lift f.hom (CategoryTheory.CategoryStruct.id f.left)

full_name: CategoryTheory.overToCoalgebra
code: /-- The backward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
goal: CategoryTheory.Functor (CategoryTheory.Over X) (CategoryTheory.prodComonad X).Coalgebra

full_name: CategoryTheory.overToCoalgebra_map_f
code: /-- The backward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
goal: ∀ {X_1 Y : CategoryTheory.Over X} (g : X_1 ⟶ Y), ((CategoryTheory.overToCoalgebra X).map g).f = g.left

full_name: CategoryTheory.overToCoalgebra_obj_A
code: /-- The backward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X) 
goal: ((CategoryTheory.overToCoalgebra X).obj f).A = f.left

full_name: CategoryTheory.coalgebraEquivOver_counitIso
code: /-- The equivalence from coalgebras for the product comonad to the over category. -/
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
goal: (CategoryTheory.coalgebraEquivOver X).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun f =>
      CategoryTheory.Over.isoMk
        (CategoryTheory.Iso.refl
          (((CategoryTheory.overToCoalgebra X).comp (CategoryTheory.coalgebraToOver X)).obj f).left)
        ⋯)
    ⋯

full_name: CategoryTheory.coalgebraEquivOver_functor
code: /-- The equivalence from coalgebras for the product comonad to the over category. -/
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
goal: (CategoryTheory.coalgebraEquivOver X).functor = CategoryTheory.coalgebraToOver X

full_name: CategoryTheory.coalgebraEquivOver_unitIso
code: /-- The equivalence from coalgebras for the product comonad to the over category. -/
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
goal: (CategoryTheory.coalgebraEquivOver X).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun A =>
      CategoryTheory.Comonad.Coalgebra.isoMk
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.prodComonad X).Coalgebra).obj A).A) ⋯)
    ⋯

full_name: CategoryTheory.coalgebraEquivOver_inverse
code: /-- The equivalence from coalgebras for the product comonad to the over category. -/
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
goal: (CategoryTheory.coalgebraEquivOver X).inverse = CategoryTheory.overToCoalgebra X

full_name: CategoryTheory.coalgebraEquivOver
code: /-- The equivalence from coalgebras for the product comonad to the over category. -/
@[simps]
def coalgebraEquivOver : Coalgebra (prodComonad X) ≌ Over X 
goal: (CategoryTheory.prodComonad X).Coalgebra ≌ CategoryTheory.Over X

full_name: CategoryTheory.coprodMonad_η_app
code: /-- `X ⨿ -` has a monad structure. This is sometimes called the either monad. -/
@[simps!]
def coprodMonad : Monad C 
goal: (CategoryTheory.coprodMonad X).η.app Y = CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.coprodMonad
code: /-- `X ⨿ -` has a monad structure. This is sometimes called the either monad. -/
@[simps!]
def coprodMonad : Monad C 
goal: CategoryTheory.Monad C

full_name: CategoryTheory.coprodMonad_μ_app
code: /-- `X ⨿ -` has a monad structure. This is sometimes called the either monad. -/
@[simps!]
def coprodMonad : Monad C 
goal: (CategoryTheory.coprodMonad X).μ.app Y =
  CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inl (CategoryTheory.CategoryStruct.id (X ⨿ Y))

full_name: CategoryTheory.coprodMonad_obj
code: /-- `X ⨿ -` has a monad structure. This is sometimes called the either monad. -/
@[simps!]
def coprodMonad : Monad C 
goal: (CategoryTheory.coprodMonad X).obj Y = (X ⨿ Y)

full_name: CategoryTheory.coprodMonad_map
code: /-- `X ⨿ -` has a monad structure. This is sometimes called the either monad. -/
@[simps!]
def coprodMonad : Monad C 
goal: (CategoryTheory.coprodMonad X).map g = CategoryTheory.Limits.coprod.map (CategoryTheory.CategoryStruct.id X) g

full_name: CategoryTheory.algebraToUnder_obj
code: /-- The forward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def algebraToUnder : Monad.Algebra (coprodMonad X) ⥤ Under X 
goal: (CategoryTheory.algebraToUnder X).obj A =
  CategoryTheory.Under.mk (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl A.a)

full_name: CategoryTheory.algebraToUnder
code: /-- The forward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def algebraToUnder : Monad.Algebra (coprodMonad X) ⥤ Under X 
goal: CategoryTheory.Functor (CategoryTheory.coprodMonad X).Algebra (CategoryTheory.Under X)

full_name: CategoryTheory.algebraToUnder_map
code: /-- The forward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def algebraToUnder : Monad.Algebra (coprodMonad X) ⥤ Under X 
goal: ∀ {X_1 Y : (CategoryTheory.coprodMonad X).Algebra} (f : X_1 ⟶ Y),
  (CategoryTheory.algebraToUnder X).map f = CategoryTheory.Under.homMk f.f ⋯

full_name: CategoryTheory.underToAlgebra
code: /-- The backward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def underToAlgebra : Under X ⥤ Monad.Algebra (coprodMonad X) 
goal: CategoryTheory.Functor (CategoryTheory.Under X) (CategoryTheory.coprodMonad X).Algebra

full_name: CategoryTheory.underToAlgebra_map_f
code: /-- The backward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def underToAlgebra : Under X ⥤ Monad.Algebra (coprodMonad X) 
goal: ∀ {X_1 Y : CategoryTheory.Under X} (g : X_1 ⟶ Y), ((CategoryTheory.underToAlgebra X).map g).f = g.right

full_name: CategoryTheory.underToAlgebra_obj_a
code: /-- The backward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def underToAlgebra : Under X ⥤ Monad.Algebra (coprodMonad X) 
goal: ((CategoryTheory.underToAlgebra X).obj f).a =
  CategoryTheory.Limits.coprod.desc f.hom (CategoryTheory.CategoryStruct.id f.right)

full_name: CategoryTheory.underToAlgebra_obj_A
code: /-- The backward direction of the equivalence from algebras for the coproduct monad to the under
category.
-/
@[simps]
def underToAlgebra : Under X ⥤ Monad.Algebra (coprodMonad X) 
goal: ((CategoryTheory.underToAlgebra X).obj f).A = f.right

full_name: CategoryTheory.algebraEquivUnder_functor
code: /-- The equivalence from algebras for the coproduct monad to the under category.
-/
@[simps]
def algebraEquivUnder : Monad.Algebra (coprodMonad X) ≌ Under X 
goal: (CategoryTheory.algebraEquivUnder X).functor = CategoryTheory.algebraToUnder X

full_name: CategoryTheory.algebraEquivUnder
code: /-- The equivalence from algebras for the coproduct monad to the under category.
-/
@[simps]
def algebraEquivUnder : Monad.Algebra (coprodMonad X) ≌ Under X 
goal: (CategoryTheory.coprodMonad X).Algebra ≌ CategoryTheory.Under X

full_name: CategoryTheory.algebraEquivUnder_unitIso
code: /-- The equivalence from algebras for the coproduct monad to the under category.
-/
@[simps]
def algebraEquivUnder : Monad.Algebra (coprodMonad X) ≌ Under X 
goal: (CategoryTheory.algebraEquivUnder X).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun A =>
      CategoryTheory.Monad.Algebra.isoMk
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.coprodMonad X).Algebra).obj A).A) ⋯)
    ⋯

full_name: CategoryTheory.algebraEquivUnder_counitIso
code: /-- The equivalence from algebras for the coproduct monad to the under category.
-/
@[simps]
def algebraEquivUnder : Monad.Algebra (coprodMonad X) ≌ Under X 
goal: (CategoryTheory.algebraEquivUnder X).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun f =>
      CategoryTheory.Under.isoMk
        (CategoryTheory.Iso.refl
          (((CategoryTheory.underToAlgebra X).comp (CategoryTheory.algebraToUnder X)).obj f).right)
        ⋯)
    ⋯

full_name: CategoryTheory.algebraEquivUnder_inverse
code: /-- The equivalence from algebras for the coproduct monad to the under category.
-/
@[simps]
def algebraEquivUnder : Monad.Algebra (coprodMonad X) ≌ Under X 
goal: (CategoryTheory.algebraEquivUnder X).inverse = CategoryTheory.underToAlgebra X