File: Mathlib/RepresentationTheory/Action/Concrete.lean

full_name: Action.ofMulAction
code: /-- Bundles a type `H` with a multiplicative action of `G` as an `Action`. -/
def ofMulAction (G H : Type u) [Monoid G] [MulAction G H] : Action (Type u) (MonCat.of G) 
goal: Action (Type u) (MonCat.of G)

full_name: Action.ofMulAction_apply
code: @[simp]
theorem ofMulAction_apply {G H : Type u} [Monoid G] [MulAction G H] (g : G) (x : H) :
    (ofMulAction G H).ρ g x = (g • x : H) 
goal: (Action.ofMulAction G H).ρ g x = g • x

full_name: Action.ofMulActionLimitCone
code: /-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor fun i => Action.ofMulAction G (F i))

full_name: Action.leftRegular
code: /-- The `G`-set `G`, acting on itself by left multiplication. -/
@[simps!]
def leftRegular (G : Type u) [Monoid G] : Action (Type u) (MonCat.of G) 
goal: Action (Type u) (MonCat.of G)

full_name: Action.leftRegular_V
code: /-- The `G`-set `G`, acting on itself by left multiplication. -/
@[simps!]
def leftRegular (G : Type u) [Monoid G] : Action (Type u) (MonCat.of G) 
goal: (Action.leftRegular G).V = G

full_name: Action.leftRegular_ρ_apply
code: /-- The `G`-set `G`, acting on itself by left multiplication. -/
@[simps!]
def leftRegular (G : Type u) [Monoid G] : Action (Type u) (MonCat.of G) 
goal: ∀ (x : ↑(MonCat.of G)) (x_1 : G), (Action.leftRegular G).ρ x x_1 = x * x_1

full_name: Action.diagonal_ρ_apply
code: /-- The `G`-set `Gⁿ`, acting on itself by left multiplication. -/
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G) 
goal: ∀ (x : ↑(MonCat.of G)) (x_1 : Fin n → G) (a : Fin n), (Action.diagonal G n).ρ x x_1 a = (x • x_1) a

full_name: Action.diagonal_V
code: /-- The `G`-set `Gⁿ`, acting on itself by left multiplication. -/
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G) 
goal: (Action.diagonal G n).V = (Fin n → G)

full_name: Action.diagonal
code: /-- The `G`-set `Gⁿ`, acting on itself by left multiplication. -/
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G) 
goal: Action (Type u) (MonCat.of G)

full_name: Action.diagonalOneIsoLeftRegular
code: /-- We have `fin 1 → G ≅ G` as `G`-sets, with `G` acting by left multiplication. -/
def diagonalOneIsoLeftRegular (G : Type u) [Monoid G] : diagonal G 1 ≅ leftRegular G 
goal: Action.diagonal G 1 ≅ Action.leftRegular G

full_name: Action.FintypeCat.ofMulAction
code: /-- Bundles a finite type `H` with a multiplicative action of `G` as an `Action`. -/
def ofMulAction (G : Type u) (H : FintypeCat.{u}) [Monoid G] [MulAction G H] :
    Action FintypeCat (MonCat.of G) 
goal: Action FintypeCat (MonCat.of G)

full_name: Action.FintypeCat.ofMulAction_apply
code: @[simp]
theorem ofMulAction_apply {G : Type u} {H : FintypeCat.{u}} [Monoid G] [MulAction G H]
    (g : G) (x : H) : (FintypeCat.ofMulAction G H).ρ g x = (g • x : H) 
goal: (Action.FintypeCat.ofMulAction G H).ρ g x = g • x

full_name: Action.instMulAction
code: instance instMulAction {G : MonCat.{u}} (X : Action V G) :
    MulAction G ((CategoryTheory.forget _).obj X) 
goal: MulAction (↑G) ((CategoryTheory.forget (Action V G)).obj X)

full_name: Action.instMulActionαMonoidFintypeVFintypeCat
code: instance {G : MonCat.{u}} (X : Action FintypeCat G) : MulAction G X.V 
goal: MulAction ↑G ↑X.V

full_name: Action.instMulActionαFintypeVFintypeCat
code: instance {G : Type u} [Group G] (X : Action FintypeCat (MonCat.of G)) : MulAction G X.V 
goal: MulAction G ↑X.V