File: Mathlib/RepresentationTheory/Basic.lean

full_name: Representation
code: /-- A representation of `G` on the `k`-module `V` is a homomorphism `G →* (V →ₗ[k] V)`.
-/
abbrev Representation 
goal: Type (max u_2 u_3)

full_name: Representation.trivial
code: /-- The trivial representation of `G` on a `k`-module V.
-/
def trivial : Representation k G V 
goal: Representation k G V

full_name: Representation.trivial_def
code: theorem trivial_def (g : G) (v : V) : trivial k (V := V) g v = v 
goal: ((Representation.trivial k) g) v = v

full_name: Representation.IsTrivial
code: /-- A predicate for representations that fix every element. -/
class IsTrivial (ρ : Representation k G V) : Prop where
  out : ∀ g x, ρ g x = x := by aesop
goal: Prop

full_name: Representation.IsTrivial.out
code: /-- A predicate for representations that fix every element. -/
class IsTrivial (ρ : Representation k G V) : Prop where
  out : ∀ g x, ρ g x = x := by aesop
goal: (ρ g) x = x

full_name: Representation.instIsTrivialTrivial
code: instance : IsTrivial (trivial k (G := G) (V := V)) 
goal: (Representation.trivial k).IsTrivial

full_name: Representation.apply_eq_self
code: @[simp] theorem apply_eq_self
    (ρ : Representation k G V) (g : G) (x : V) [h : IsTrivial ρ] :
    ρ g x = x 
goal: (ρ g) x = x

full_name: Representation.asAlgebraHom
code: /-- A `k`-linear representation of `G` on `V` can be thought of as
an algebra map from `MonoidAlgebra k G` into the `k`-linear endomorphisms of `V`.
-/
noncomputable def asAlgebraHom : MonoidAlgebra k G →ₐ[k] Module.End k V 
goal: MonoidAlgebra k G →ₐ[k] Module.End k V

full_name: Representation.asAlgebraHom_def
code: theorem asAlgebraHom_def : asAlgebraHom ρ = (lift k G _) ρ 
goal: ρ.asAlgebraHom = (MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ

full_name: Representation.asAlgebraHom_single
code: @[simp]
theorem asAlgebraHom_single (g : G) (r : k) : asAlgebraHom ρ (Finsupp.single g r) = r • ρ g 
goal: ρ.asAlgebraHom (Finsupp.single g r) = r • ρ g

full_name: Representation.asAlgebraHom_single_one
code: theorem asAlgebraHom_single_one (g : G) : asAlgebraHom ρ (Finsupp.single g 1) = ρ g 
goal: ρ.asAlgebraHom (Finsupp.single g 1) = ρ g

full_name: Representation.asAlgebraHom_of
code: theorem asAlgebraHom_of (g : G) : asAlgebraHom ρ (of k G g) = ρ g 
goal: ρ.asAlgebraHom ((MonoidAlgebra.of k G) g) = ρ g

full_name: Representation.asModule
code: /-- If `ρ : Representation k G V`, then `ρ.asModule` is a type synonym for `V`,
which we equip with an instance `Module (MonoidAlgebra k G) ρ.asModule`.

You should use `asModuleEquiv : ρ.asModule ≃+ V` to translate terms.
-/
@[nolint unusedArguments]
def asModule (_ : Representation k G V) 
goal: Representation k G V → Type u_3

full_name: Representation.instAddCommMonoidAsModule
code: instance : AddCommMonoid (ρ.asModule) 
goal: AddCommMonoid ρ.asModule

full_name: Representation.instInhabitedAsModule
code: instance : Inhabited ρ.asModule 
goal: Inhabited ρ.asModule

full_name: Representation.asModuleModule
code: /-- A `k`-linear representation of `G` on `V` can be thought of as
a module over `MonoidAlgebra k G`.
-/
noncomputable instance asModuleModule : Module (MonoidAlgebra k G) ρ.asModule 
goal: Module (MonoidAlgebra k G) ρ.asModule

full_name: Representation.instModuleAsModule
code: instance : Module k ρ.asModule 
goal: Module k ρ.asModule

full_name: Representation.asModuleEquiv
code: /-- The additive equivalence from the `Module (MonoidAlgebra k G)` to the original vector space
of the representative.

This is just the identity, but it is helpful for typechecking and keeping track of instances.
-/
def asModuleEquiv : ρ.asModule ≃+ V 
goal: ρ.asModule ≃+ V

full_name: Representation.asModuleEquiv_map_smul
code: @[simp]
theorem asModuleEquiv_map_smul (r : MonoidAlgebra k G) (x : ρ.asModule) :
    ρ.asModuleEquiv (r • x) = ρ.asAlgebraHom r (ρ.asModuleEquiv x) 
goal: ρ.asModuleEquiv (r • x) = (ρ.asAlgebraHom r) (ρ.asModuleEquiv x)

full_name: Representation.asModuleEquiv_symm_map_smul
code: @[simp]
theorem asModuleEquiv_symm_map_smul (r : k) (x : V) :
    ρ.asModuleEquiv.symm (r • x) = algebraMap k (MonoidAlgebra k G) r • ρ.asModuleEquiv.symm x 
goal: ρ.asModuleEquiv.symm (r • x) = (algebraMap k (MonoidAlgebra k G)) r • ρ.asModuleEquiv.symm x

full_name: Representation.asModuleEquiv_symm_map_rho
code: @[simp]
theorem asModuleEquiv_symm_map_rho (g : G) (x : V) :
    ρ.asModuleEquiv.symm (ρ g x) = MonoidAlgebra.of k G g • ρ.asModuleEquiv.symm x 
goal: ρ.asModuleEquiv.symm ((ρ g) x) = (MonoidAlgebra.of k G) g • ρ.asModuleEquiv.symm x

full_name: Representation.ofModule'
code: /-- Build a `Representation k G M` from a `[Module (MonoidAlgebra k G) M]`.

This version is not always what we want, as it relies on an existing `[Module k M]`
instance, along with a `[IsScalarTower k (MonoidAlgebra k G) M]` instance.

We remedy this below in `ofModule`
(with the tradeoff that the representation is defined
only on a type synonym of the original module.)
-/
noncomputable def ofModule' (M : Type*) [AddCommMonoid M] [Module k M]
    [Module (MonoidAlgebra k G) M] [IsScalarTower k (MonoidAlgebra k G) M] : Representation k G M 
goal: Representation k G M

full_name: Representation.ofModule
code: /-- Build a `Representation` from a `[Module (MonoidAlgebra k G) M]`.

Note that the representation is built on `restrictScalars k (MonoidAlgebra k G) M`,
rather than on `M` itself.
-/
noncomputable def ofModule : Representation k G (RestrictScalars k (MonoidAlgebra k G) M) 
goal: Representation k G (RestrictScalars k (MonoidAlgebra k G) M)

full_name: Representation.ofModule_asAlgebraHom_apply_apply
code: @[simp]
theorem ofModule_asAlgebraHom_apply_apply (r : MonoidAlgebra k G)
    (m : RestrictScalars k (MonoidAlgebra k G) M) :
    ((ofModule M).asAlgebraHom r) m =
      (RestrictScalars.addEquiv _ _ _).symm (r • RestrictScalars.addEquiv _ _ _ m) 
goal: ((Representation.ofModule M).asAlgebraHom r) m =
  (RestrictScalars.addEquiv k (MonoidAlgebra k G) M).symm (r • (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) m)

full_name: Representation.ofModule_asModule_act
code: @[simp]
theorem ofModule_asModule_act (g : G) (x : RestrictScalars k (MonoidAlgebra k G) ρ.asModule) :
    ofModule (k := k) (G := G) ρ.asModule g x = -- Porting note: more help with implicit
      (RestrictScalars.addEquiv _ _ _).symm
        (ρ.asModuleEquiv.symm (ρ g (ρ.asModuleEquiv (RestrictScalars.addEquiv _ _ _ x)))) 
goal: ((Representation.ofModule ρ.asModule) g) x =
  (RestrictScalars.addEquiv k (MonoidAlgebra k G) ρ.asModule).symm
    (ρ.asModuleEquiv.symm ((ρ g) (ρ.asModuleEquiv ((RestrictScalars.addEquiv k (MonoidAlgebra k G) ρ.asModule) x))))

full_name: Representation.smul_ofModule_asModule
code: theorem smul_ofModule_asModule (r : MonoidAlgebra k G) (m : (ofModule M).asModule) :
    (RestrictScalars.addEquiv k _ _) ((ofModule M).asModuleEquiv (r • m)) =
      r • (RestrictScalars.addEquiv k _ _) ((ofModule M).asModuleEquiv (G := G) m) 
goal: (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) ((Representation.ofModule M).asModuleEquiv (r • m)) =
  r • (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) ((Representation.ofModule M).asModuleEquiv m)

full_name: Representation.instAddCommGroupAsModule
code: instance : AddCommGroup ρ.asModule 
goal: AddCommGroup ρ.asModule

full_name: Representation.ofMulAction
code: /-- A `G`-action on `H` induces a representation `G →* End(k[H])` in the natural way. -/
noncomputable def ofMulAction : Representation k G (H →₀ k) 
goal: Representation k G (H →₀ k)

full_name: Representation.ofMulAction_def
code: theorem ofMulAction_def (g : G) : ofMulAction k G H g = Finsupp.lmapDomain k k (g • ·) 
goal: (Representation.ofMulAction k G H) g = Finsupp.lmapDomain k k fun x => g • x

full_name: Representation.ofMulAction_single
code: theorem ofMulAction_single (g : G) (x : H) (r : k) :
    ofMulAction k G H g (Finsupp.single x r) = Finsupp.single (g • x) r 
goal: ((Representation.ofMulAction k G H) g) (Finsupp.single x r) = Finsupp.single (g • x) r

full_name: Representation.ofDistribMulAction
code: /-- Turns a `k`-module `A` with a compatible `DistribMulAction` of a monoid `G` into a
`k`-linear `G`-representation on `A`. -/
def ofDistribMulAction : Representation k G A 
goal: Representation k G A

full_name: Representation.ofDistribMulAction_apply_apply
code: @[simp] theorem ofDistribMulAction_apply_apply (g : G) (a : A) :
    ofDistribMulAction k G A g a = g • a 
goal: ((Representation.ofDistribMulAction k G A) g) a = g • a

full_name: Representation.ofMulDistribMulAction
code: /-- Turns a `CommGroup` `G` with a `MulDistribMulAction` of a monoid `M` into a
`ℤ`-linear `M`-representation on `Additive G`. -/
def ofMulDistribMulAction : Representation ℤ M (Additive G) 
goal: Representation ℤ M (Additive G)

full_name: Representation.ofMulDistribMulAction_apply_apply
code: @[simp] theorem ofMulDistribMulAction_apply_apply (g : M) (a : Additive G) :
    ofMulDistribMulAction M G g a = Additive.ofMul (g • Additive.toMul a) 
goal: ((Representation.ofMulDistribMulAction M G) g) a = Additive.ofMul (g • Additive.toMul a)

full_name: Representation.ofMulAction_apply
code: @[simp]
theorem ofMulAction_apply {H : Type*} [MulAction G H] (g : G) (f : H →₀ k) (h : H) :
    ofMulAction k G H g f h = f (g⁻¹ • h) 
goal: (((Representation.ofMulAction k G H) g) f) h = f (g⁻¹ • h)

full_name: Representation.instHMulMonoidAlgebraAsModuleFinsuppOfMulAction
code: noncomputable instance :
    HMul (MonoidAlgebra k G) ((ofMulAction k G G).asModule) (MonoidAlgebra k G) 
goal: HMul (MonoidAlgebra k G) (Representation.ofMulAction k G G).asModule (MonoidAlgebra k G)

full_name: Representation.ofMulAction_self_smul_eq_mul
code: theorem ofMulAction_self_smul_eq_mul (x : MonoidAlgebra k G) (y : (ofMulAction k G G).asModule) :
    x • y = (x * y : MonoidAlgebra k G) 
goal: x • y = x * y

full_name: Representation.ofMulActionSelfAsModuleEquiv_symm_apply
code: /-- If we equip `k[G]` with the `k`-linear `G`-representation induced by the left regular action of
`G` on itself, the resulting object is isomorphic as a `k[G]`-module to `k[G]` with its natural
`k[G]`-module structure. -/
@[simps]
noncomputable def ofMulActionSelfAsModuleEquiv :
    (ofMulAction k G G).asModule ≃ₗ[MonoidAlgebra k G] MonoidAlgebra k G 
goal: ∀ (a : G →₀ k),
  Representation.ofMulActionSelfAsModuleEquiv.symm a = (Representation.ofMulAction k G G).asModuleEquiv.invFun a

full_name: Representation.ofMulActionSelfAsModuleEquiv_apply
code: /-- If we equip `k[G]` with the `k`-linear `G`-representation induced by the left regular action of
`G` on itself, the resulting object is isomorphic as a `k[G]`-module to `k[G]` with its natural
`k[G]`-module structure. -/
@[simps]
noncomputable def ofMulActionSelfAsModuleEquiv :
    (ofMulAction k G G).asModule ≃ₗ[MonoidAlgebra k G] MonoidAlgebra k G 
goal: ∀ (a : (Representation.ofMulAction k G G).asModule),
  Representation.ofMulActionSelfAsModuleEquiv a = (Representation.ofMulAction k G G).asModuleEquiv.toFun a

full_name: Representation.ofMulActionSelfAsModuleEquiv
code: /-- If we equip `k[G]` with the `k`-linear `G`-representation induced by the left regular action of
`G` on itself, the resulting object is isomorphic as a `k[G]`-module to `k[G]` with its natural
`k[G]`-module structure. -/
@[simps]
noncomputable def ofMulActionSelfAsModuleEquiv :
    (ofMulAction k G G).asModule ≃ₗ[MonoidAlgebra k G] MonoidAlgebra k G 
goal: (Representation.ofMulAction k G G).asModule ≃ₗ[MonoidAlgebra k G] MonoidAlgebra k G

full_name: Representation.asGroupHom
code: /-- When `G` is a group, a `k`-linear representation of `G` on `V` can be thought of as
a group homomorphism from `G` into the invertible `k`-linear endomorphisms of `V`.
-/
def asGroupHom : G →* Units (V →ₗ[k] V) 
goal: G →* (V →ₗ[k] V)ˣ

full_name: Representation.asGroupHom_apply
code: theorem asGroupHom_apply (g : G) : ↑(asGroupHom ρ g) = ρ g 
goal: ↑(ρ.asGroupHom g) = ρ g

full_name: Representation.tprod
code: /-- Given representations of `G` on `V` and `W`, there is a natural representation of `G` on their
tensor product `V ⊗[k] W`.
-/
noncomputable def tprod : Representation k G (V ⊗[k] W) 
goal: Representation k G (TensorProduct k V W)

full_name: Representation.«_aux_Mathlib_RepresentationTheory_Basic___macroRules_Representation_term_⊗__1»
code: local notation ρV " ⊗ " ρW => tprod ρV ρW
goal: Lean.Macro

full_name: Representation._aux_Mathlib_RepresentationTheory_Basic___unexpand_Representation_tprod_1
code: local notation ρV " ⊗ " ρW => tprod ρV ρW
goal: Lean.PrettyPrinter.Unexpander

full_name: Representation.tprod_apply
code: @[simp]
theorem tprod_apply (g : G) : (ρV ⊗ ρW) g = TensorProduct.map (ρV g) (ρW g) 
goal: (ρV.tprod ρW) g = TensorProduct.map (ρV g) (ρW g)

full_name: Representation.smul_tprod_one_asModule
code: theorem smul_tprod_one_asModule (r : MonoidAlgebra k G) (x : V) (y : W) :
    -- Porting note: required to since Lean 4 doesn't unfold asModule
    let x' : ρV.asModule := x
    let z : (ρV.tprod 1).asModule := x ⊗ₜ y
    r • z = (r • x') ⊗ₜ y 
goal: let x' := x;
let z := x ⊗ₜ[k] y;
r • z = (r • x') ⊗ₜ[k] y

full_name: Representation.smul_one_tprod_asModule
code: theorem smul_one_tprod_asModule (r : MonoidAlgebra k G) (x : V) (y : W) :
    -- Porting note: required to since Lean 4 doesn't unfold asModule
    let y' : ρW.asModule := y
    let z : (1 ⊗ ρW).asModule := x ⊗ₜ y
    r • z = x ⊗ₜ (r • y') 
goal: let y' := y;
let z := x ⊗ₜ[k] y;
r • z = x ⊗ₜ[k] (r • y')

full_name: Representation.linHom
code: /-- Given representations of `G` on `V` and `W`, there is a natural representation of `G` on the
module `V →ₗ[k] W`, where `G` acts by conjugation.
-/
def linHom : Representation k G (V →ₗ[k] W) 
goal: Representation k G (V →ₗ[k] W)

full_name: Representation.linHom_apply
code: @[simp]
theorem linHom_apply (g : G) (f : V →ₗ[k] W) : (linHom ρV ρW) g f = ρW g ∘ₗ f ∘ₗ ρV g⁻¹ 
goal: ((ρV.linHom ρW) g) f = ρW g ∘ₗ f ∘ₗ ρV g⁻¹

full_name: Representation.dual
code: /-- The dual of a representation `ρ` of `G` on a module `V`, given by `(dual ρ) g f = f ∘ₗ (ρ g⁻¹)`,
where `f : Module.Dual k V`.
-/
def dual : Representation k G (Module.Dual k V) 
goal: Representation k G (Module.Dual k V)

full_name: Representation.dual_apply
code: @[simp]
theorem dual_apply (g : G) : (dual ρV) g = Module.Dual.transpose (R := k) (ρV g⁻¹) 
goal: ρV.dual g = Module.Dual.transpose (ρV g⁻¹)

full_name: Representation.dualTensorHom_comm
code: /-- Given $k$-modules $V, W$, there is a homomorphism $φ : V^* ⊗ W → Hom_k(V, W)$
(implemented by `LinearAlgebra.Contraction.dualTensorHom`).
Given representations of $G$ on $V$ and $W$,there are representations of $G$ on $V^* ⊗ W$ and on
$Hom_k(V, W)$.
This lemma says that $φ$ is $G$-linear.
-/
theorem dualTensorHom_comm (g : G) :
    dualTensorHom k V W ∘ₗ TensorProduct.map (ρV.dual g) (ρW g) =
      (linHom ρV ρW) g ∘ₗ dualTensorHom k V W 
goal: dualTensorHom k V W ∘ₗ TensorProduct.map (ρV.dual g) (ρW g) = (ρV.linHom ρW) g ∘ₗ dualTensorHom k V W