File: Mathlib/CategoryTheory/Monoidal/Mod_.lean

full_name: Mod_.assoc
code: /-- A module object for a monoid object, all internal to some monoidal category. -/
structure Mod_ (A : Mon_ C) where
  X : C
  act : A.X ⊗ X ⟶ X
  one_act : (A.one ▷ X) ≫ act = (λ_ X).hom := by aesop_cat
  assoc : (A.mul ▷ X) ≫ act = (α_ A.X A.X X).hom ≫ (A.X ◁ act) ≫ act := by aesop_cat
goal: A.mul ▷ self.X ≫ self.act = (α_ A.X A.X self.X).hom ≫ A.X ◁ self.act ≫ self.act

full_name: Mod_.one_act
code: /-- A module object for a monoid object, all internal to some monoidal category. -/
structure Mod_ (A : Mon_ C) where
  X : C
  act : A.X ⊗ X ⟶ X
  one_act : (A.one ▷ X) ≫ act = (λ_ X).hom := by aesop_cat
  assoc : (A.mul ▷ X) ≫ act = (α_ A.X A.X X).hom ≫ (A.X ◁ act) ≫ act := by aesop_cat
goal: A.one ▷ self.X ≫ self.act = (λ_ self.X).hom

full_name: Mod_.act
code: /-- A module object for a monoid object, all internal to some monoidal category. -/
structure Mod_ (A : Mon_ C) where
  X : C
  act : A.X ⊗ X ⟶ X
  one_act : (A.one ▷ X) ≫ act = (λ_ X).hom := by aesop_cat
  assoc : (A.mul ▷ X) ≫ act = (α_ A.X A.X X).hom ≫ (A.X ◁ act) ≫ act := by aesop_cat
goal: A.X ⊗ self.X ⟶ self.X

full_name: Mod_.X
code: /-- A module object for a monoid object, all internal to some monoidal category. -/
structure Mod_ (A : Mon_ C) where
  X : C
  act : A.X ⊗ X ⟶ X
  one_act : (A.one ▷ X) ≫ act = (λ_ X).hom := by aesop_cat
  assoc : (A.mul ▷ X) ≫ act = (α_ A.X A.X X).hom ≫ (A.X ◁ act) ≫ act := by aesop_cat
goal: C

full_name: Mod_
code: /-- A module object for a monoid object, all internal to some monoidal category. -/
structure Mod_ (A : Mon_ C) where
  X : C
  act : A.X ⊗ X ⟶ X
  one_act : (A.one ▷ X) ≫ act = (λ_ X).hom := by aesop_cat
  assoc : (A.mul ▷ X) ≫ act = (α_ A.X A.X X).hom ≫ (A.X ◁ act) ≫ act := by aesop_cat
goal: Type (max u₁ v₁)

full_name: Mod_.assoc_flip
code: theorem assoc_flip :
    (A.X ◁ M.act) ≫ M.act = (α_ A.X A.X M.X).inv ≫ (A.mul ▷ M.X) ≫ M.act 
goal: A.X ◁ M.act ≫ M.act = (α_ A.X A.X M.X).inv ≫ A.mul ▷ M.X ≫ M.act

full_name: Mod_.Hom.hom
code: /-- A morphism of module objects. -/
@[ext]
structure Hom (M N : Mod_ A) where
  hom : M.X ⟶ N.X
  act_hom : M.act ≫ hom = (A.X ◁ hom) ≫ N.act := by aesop_cat
goal: M.X ⟶ N.X

full_name: Mod_.Hom.act_hom
code: /-- A morphism of module objects. -/
@[ext]
structure Hom (M N : Mod_ A) where
  hom : M.X ⟶ N.X
  act_hom : M.act ≫ hom = (A.X ◁ hom) ≫ N.act := by aesop_cat
goal: M.act ≫ self.hom = A.X ◁ self.hom ≫ N.act

full_name: Mod_.Hom
code: /-- A morphism of module objects. -/
@[ext]
structure Hom (M N : Mod_ A) where
  hom : M.X ⟶ N.X
  act_hom : M.act ≫ hom = (A.X ◁ hom) ≫ N.act := by aesop_cat
goal: Type v₁

full_name: Mod_.id_hom
code: /-- The identity morphism on a module object. -/
@[simps]
def id (M : Mod_ A) : Hom M M 
goal: M.id.hom = 𝟙 M.X

full_name: Mod_.id
code: /-- The identity morphism on a module object. -/
@[simps]
def id (M : Mod_ A) : Hom M M 
goal: M.Hom M

full_name: Mod_.homInhabited
code: instance homInhabited (M : Mod_ A) : Inhabited (Hom M M) 
goal: Inhabited (M.Hom M)

full_name: Mod_.comp_hom
code: /-- Composition of module object morphisms. -/
@[simps]
def comp {M N O : Mod_ A} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: (Mod_.comp f g).hom = f.hom ≫ g.hom

full_name: Mod_.comp
code: /-- Composition of module object morphisms. -/
@[simps]
def comp {M N O : Mod_ A} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: M.Hom O

full_name: Mod_.instCategory
code: instance : Category (Mod_ A) 
goal: CategoryTheory.Category.{v₁, max u₁ v₁} (Mod_ A)

full_name: Mod_.hom_ext
code: @[ext]
lemma hom_ext {M N : Mod_ A} (f₁ f₂ : M ⟶ N) (h : f₁.hom = f₂.hom) : f₁ = f₂ 
goal: f₁ = f₂

full_name: Mod_.id_hom'
code: @[simp]
theorem id_hom' (M : Mod_ A) : (𝟙 M : M ⟶ M).hom = 𝟙 M.X 
goal: (𝟙 M).hom = 𝟙 M.X

full_name: Mod_.comp_hom'
code: @[simp]
theorem comp_hom' {M N K : Mod_ A} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g).hom = f.hom ≫ g.hom 
goal: (f ≫ g).hom = f.hom ≫ g.hom

full_name: Mod_.regular
code: /-- A monoid object as a module over itself. -/
@[simps]
def regular : Mod_ A 
goal: Mod_ A

full_name: Mod_.regular_act
code: /-- A monoid object as a module over itself. -/
@[simps]
def regular : Mod_ A 
goal: (Mod_.regular A).act = A.mul

full_name: Mod_.regular_X
code: /-- A monoid object as a module over itself. -/
@[simps]
def regular : Mod_ A 
goal: (Mod_.regular A).X = A.X

full_name: Mod_.instInhabited
code: instance : Inhabited (Mod_ A) 
goal: Inhabited (Mod_ A)

full_name: Mod_.forget
code: /-- The forgetful functor from module objects to the ambient category. -/
def forget : Mod_ A ⥤ C 
goal: Mod_ A ⥤ C

full_name: Mod_.comap_obj_act
code: /-- A morphism of monoid objects induces a "restriction" or "comap" functor
between the categories of module objects.
-/
@[simps]
def comap {A B : Mon_ C} (f : A ⟶ B) : Mod_ B ⥤ Mod_ A 
goal: ((Mod_.comap f).obj M).act = f.hom ▷ M.X ≫ M.act

full_name: Mod_.comap_obj_X
code: /-- A morphism of monoid objects induces a "restriction" or "comap" functor
between the categories of module objects.
-/
@[simps]
def comap {A B : Mon_ C} (f : A ⟶ B) : Mod_ B ⥤ Mod_ A 
goal: ((Mod_.comap f).obj M).X = M.X

full_name: Mod_.comap_map_hom
code: /-- A morphism of monoid objects induces a "restriction" or "comap" functor
between the categories of module objects.
-/
@[simps]
def comap {A B : Mon_ C} (f : A ⟶ B) : Mod_ B ⥤ Mod_ A 
goal: ∀ {X Y : Mod_ B} (g : X ⟶ Y), ((Mod_.comap f).map g).hom = g.hom

full_name: Mod_.comap
code: /-- A morphism of monoid objects induces a "restriction" or "comap" functor
between the categories of module objects.
-/
@[simps]
def comap {A B : Mon_ C} (f : A ⟶ B) : Mod_ B ⥤ Mod_ A 
goal: Mod_ B ⥤ Mod_ A