File: Mathlib/RepresentationTheory/Rep.lean

full_name: Rep
code: /-- The category of `k`-linear representations of a monoid `G`. -/
abbrev Rep (k G : Type u) [Ring k] [Monoid G] 
goal: Type (u + 1)

full_name: instLinearRep
code: instance (k G : Type u) [CommRing k] [Monoid G] : Linear k (Rep k G) 
goal: CategoryTheory.Linear k (Rep k G)

full_name: Rep.instCoeSortType
code: instance : CoeSort (Rep k G) (Type u) 
goal: CoeSort (Rep k G) (Type u)

full_name: Rep.instAddCommGroupCoe
code: instance (V : Rep k G) : AddCommGroup V 
goal: AddCommGroup (CoeSort.coe V)

full_name: Rep.instModuleCoe
code: instance (V : Rep k G) : Module k V 
goal: Module k (CoeSort.coe V)

full_name: Rep.ρ
code: /-- Specialize the existing `Action.ρ`, changing the type to `Representation k G V`.
-/
def ρ (V : Rep k G) : Representation k G V 
goal: Representation k G (CoeSort.coe V)

full_name: Rep.of
code: /-- Lift an unbundled representation to `Rep`. -/
def of {V : Type u} [AddCommGroup V] [Module k V] (ρ : G →* V →ₗ[k] V) : Rep k G 
goal: Rep k G

full_name: Rep.coe_of
code: @[simp]
theorem coe_of {V : Type u} [AddCommGroup V] [Module k V] (ρ : G →* V →ₗ[k] V) :
    (of ρ : Type u) = V 
goal: CoeSort.coe (Rep.of ρ) = V

full_name: Rep.of_ρ
code: @[simp]
theorem of_ρ {V : Type u} [AddCommGroup V] [Module k V] (ρ : G →* V →ₗ[k] V) : (of ρ).ρ = ρ 
goal: (Rep.of ρ).ρ = ρ

full_name: Rep.Action_ρ_eq_ρ
code: theorem Action_ρ_eq_ρ {A : Rep k G} : Action.ρ A = A.ρ 
goal: A.ρ = A.ρ

full_name: Rep.of_ρ_apply
code: /-- Allows us to apply lemmas about the underlying `ρ`, which would take an element `g : G` rather
than `g : MonCat.of G` as an argument. -/
theorem of_ρ_apply {V : Type u} [AddCommGroup V] [Module k V] (ρ : Representation k G V)
    (g : MonCat.of G) : (Rep.of ρ).ρ g = ρ (g : G) 
goal: (Rep.of ρ).ρ g = ρ g

full_name: Rep.ρ_inv_self_apply
code: @[simp]
theorem ρ_inv_self_apply {G : Type u} [Group G] (A : Rep k G) (g : G) (x : A) :
    A.ρ g⁻¹ (A.ρ g x) = x 
goal: (A.ρ g⁻¹) ((A.ρ g) x) = x

full_name: Rep.ρ_self_inv_apply
code: @[simp]
theorem ρ_self_inv_apply {G : Type u} [Group G] {A : Rep k G} (g : G) (x : A) :
    A.ρ g (A.ρ g⁻¹ x) = x 
goal: (A.ρ g) ((A.ρ g⁻¹) x) = x

full_name: Rep.hom_comm_apply
code: theorem hom_comm_apply {A B : Rep k G} (f : A ⟶ B) (g : G) (x : A) :
    f.hom (A.ρ g x) = B.ρ g (f.hom x) 
goal: f.hom ((A.ρ g) x) = (B.ρ g) (f.hom x)

full_name: Rep.trivial
code: /-- The trivial `k`-linear `G`-representation on a `k`-module `V.` -/
def trivial (V : Type u) [AddCommGroup V] [Module k V] : Rep k G 
goal: Rep k G

full_name: Rep.trivial_def
code: theorem trivial_def {V : Type u} [AddCommGroup V] [Module k V] (g : G) (v : V) :
    (trivial k G V).ρ g v = v 
goal: ((Rep.trivial k G V).ρ g) v = v

full_name: Rep.IsTrivial
code: /-- A predicate for representations that fix every element. -/
abbrev IsTrivial (A : Rep k G) 
goal: Prop

full_name: Rep.instIsTrivialTrivial
code: instance {V : Type u} [AddCommGroup V] [Module k V] :
    IsTrivial (Rep.trivial k G V) 
goal: (Rep.trivial k G V).IsTrivial

full_name: Rep.instIsTrivialOfOfIsTrivial
code: instance {V : Type u} [AddCommGroup V] [Module k V] (ρ : Representation k G V) [ρ.IsTrivial] :
    IsTrivial (Rep.of ρ) 
goal: (Rep.of ρ).IsTrivial

full_name: Rep.instPreservesLimitsModuleCatForget₂
code: noncomputable instance : PreservesLimits (forget₂ (Rep k G) (ModuleCat.{u} k)) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ (Rep k G) (ModuleCat k))

full_name: Rep.instPreservesColimitsModuleCatForget₂
code: noncomputable instance : PreservesColimits (forget₂ (Rep k G) (ModuleCat.{u} k)) 
goal: CategoryTheory.Limits.PreservesColimits (CategoryTheory.forget₂ (Rep k G) (ModuleCat k))

full_name: Rep.MonoidalCategory.braiding_hom_apply
code: theorem MonoidalCategory.braiding_hom_apply {A B : Rep k G} (x : A) (y : B) :
    Action.Hom.hom (β_ A B).hom (TensorProduct.tmul k x y) = TensorProduct.tmul k y x 
goal: (β_ A B).hom.hom (x ⊗ₜ[k] y) = y ⊗ₜ[k] x

full_name: Rep.MonoidalCategory.braiding_inv_apply
code: theorem MonoidalCategory.braiding_inv_apply {A B : Rep k G} (x : A) (y : B) :
    Action.Hom.hom (β_ A B).inv (TensorProduct.tmul k y x) = TensorProduct.tmul k x y 
goal: (β_ A B).inv.hom (y ⊗ₜ[k] x) = x ⊗ₜ[k] y

full_name: Rep.linearization
code: /-- The monoidal functor sending a type `H` with a `G`-action to the induced `k`-linear
`G`-representation on `k[H].` -/
noncomputable def linearization : MonoidalFunctor (Action (Type u) (MonCat.of G)) (Rep k G) 
goal: CategoryTheory.MonoidalFunctor (Action (Type u) (MonCat.of G)) (Rep k G)

full_name: Rep.linearization_obj_ρ
code: @[simp]
theorem linearization_obj_ρ (X : Action (Type u) (MonCat.of G)) (g : G) (x : X.V →₀ k) :
    ((linearization k G).obj X).ρ g x = Finsupp.lmapDomain k k (X.ρ g) x 
goal: (((Rep.linearization k G).obj X).ρ g) x = (Finsupp.lmapDomain k k (X.ρ g)) x

full_name: Rep.linearization_of
code: theorem linearization_of (X : Action (Type u) (MonCat.of G)) (g : G) (x : X.V) :
    ((linearization k G).obj X).ρ g (Finsupp.single x (1 : k))
      = Finsupp.single (X.ρ g x) (1 : k) 
goal: (((Rep.linearization k G).obj X).ρ g) (Finsupp.single x 1) = Finsupp.single (X.ρ g x) 1

full_name: Rep.linearization_single
code: theorem linearization_single (X : Action (Type u) (MonCat.of G)) (g : G) (x : X.V) (r : k) :
    ((linearization k G).obj X).ρ g (Finsupp.single x r) = Finsupp.single (X.ρ g x) r 
goal: (((Rep.linearization k G).obj X).ρ g) (Finsupp.single x r) = Finsupp.single (X.ρ g x) r

full_name: Rep.linearization_map_hom
code: @[simp]
theorem linearization_map_hom : ((linearization k G).map f).hom = Finsupp.lmapDomain k k f.hom 
goal: ((Rep.linearization k G).map f).hom = Finsupp.lmapDomain k k f.hom

full_name: Rep.linearization_map_hom_single
code: theorem linearization_map_hom_single (x : X.V) (r : k) :
    ((linearization k G).map f).hom (Finsupp.single x r) = Finsupp.single (f.hom x) r 
goal: ((Rep.linearization k G).map f).hom (Finsupp.single x r) = Finsupp.single (f.hom x) r

full_name: Rep.linearization_μ_hom
code: @[simp]
theorem linearization_μ_hom (X Y : Action (Type u) (MonCat.of G)) :
    ((linearization k G).μ X Y).hom = (finsuppTensorFinsupp' k X.V Y.V).toLinearMap 
goal: ((Rep.linearization k G).μ X Y).hom = ↑(finsuppTensorFinsupp' k X.V Y.V)

full_name: Rep.linearization_μ_inv_hom
code: @[simp]
theorem linearization_μ_inv_hom (X Y : Action (Type u) (MonCat.of G)) :
    (inv ((linearization k G).μ X Y)).hom = (finsuppTensorFinsupp' k X.V Y.V).symm.toLinearMap 
goal: (CategoryTheory.inv ((Rep.linearization k G).μ X Y)).hom = ↑(finsuppTensorFinsupp' k X.V Y.V).symm

full_name: Rep.linearization_ε_hom
code: @[simp]
theorem linearization_ε_hom : (linearization k G).ε.hom = Finsupp.lsingle PUnit.unit 
goal: (Rep.linearization k G).ε.hom = Finsupp.lsingle PUnit.unit

full_name: Rep.linearization_ε_inv_hom_apply
code: theorem linearization_ε_inv_hom_apply (r : k) :
    (inv (linearization k G).ε).hom (Finsupp.single PUnit.unit r) = r 
goal: (CategoryTheory.inv (Rep.linearization k G).ε).hom (Finsupp.single PUnit.unit r) = r

full_name: Rep.linearizationTrivialIso_hom_hom_apply
code: /-- The linearization of a type `X` on which `G` acts trivially is the trivial `G`-representation
on `k[X]`. -/
@[simps!]
noncomputable def linearizationTrivialIso (X : Type u) :
    (linearization k G).obj (Action.mk X 1) ≅ trivial k G (X →₀ k) 
goal: (Rep.linearizationTrivialIso k G X).hom.hom a = a

full_name: Rep.linearizationTrivialIso
code: /-- The linearization of a type `X` on which `G` acts trivially is the trivial `G`-representation
on `k[X]`. -/
@[simps!]
noncomputable def linearizationTrivialIso (X : Type u) :
    (linearization k G).obj (Action.mk X 1) ≅ trivial k G (X →₀ k) 
goal: (Rep.linearization k G).obj { V := X, ρ := 1 } ≅ Rep.trivial k G (X →₀ k)

full_name: Rep.linearizationTrivialIso_inv_hom_apply
code: /-- The linearization of a type `X` on which `G` acts trivially is the trivial `G`-representation
on `k[X]`. -/
@[simps!]
noncomputable def linearizationTrivialIso (X : Type u) :
    (linearization k G).obj (Action.mk X 1) ≅ trivial k G (X →₀ k) 
goal: (Rep.linearizationTrivialIso k G X).inv.hom a = a

full_name: Rep.ofMulAction
code: /-- Given a `G`-action on `H`, this is `k[H]` bundled with the natural representation
`G →* End(k[H])` as a term of type `Rep k G`. -/
noncomputable abbrev ofMulAction (H : Type u) [MulAction G H] : Rep k G 
goal: Rep k G

full_name: Rep.leftRegular
code: /-- The `k`-linear `G`-representation on `k[G]`, induced by left multiplication. -/
noncomputable def leftRegular : Rep k G 
goal: Rep k G

full_name: Rep.diagonal
code: /-- The `k`-linear `G`-representation on `k[Gⁿ]`, induced by left multiplication. -/
noncomputable def diagonal (n : ℕ) : Rep k G 
goal: Rep k G

full_name: Rep.linearizationOfMulActionIso
code: /-- The linearization of a type `H` with a `G`-action is definitionally isomorphic to the
`k`-linear `G`-representation on `k[H]` induced by the `G`-action on `H`. -/
noncomputable def linearizationOfMulActionIso (H : Type u) [MulAction G H] :
    (linearization k G).obj (Action.ofMulAction G H) ≅ ofMulAction k G H 
goal: (Rep.linearization k G).obj (Action.ofMulAction G H) ≅ Rep.ofMulAction k G H

full_name: Rep.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 : Rep k G 
goal: Rep k G

full_name: Rep.ofDistribMulAction_ρ_apply_apply
code: @[simp] theorem ofDistribMulAction_ρ_apply_apply (g : G) (a : A) :
    (ofDistribMulAction k G A).ρ g a = g • a 
goal: ((Rep.ofDistribMulAction k G A).ρ g) a = g • a

full_name: Rep.ofAlgebraAut
code: /-- Given an `R`-algebra `S`, the `ℤ`-linear representation associated to the natural action of
`S ≃ₐ[R] S` on `S`. -/
@[simp] def ofAlgebraAut (R S : Type) [CommRing R] [CommRing S] [Algebra R S] :
    Rep ℤ (S ≃ₐ[R] S) 
goal: Rep ℤ (S ≃ₐ[R] S)

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

full_name: Rep.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: ((Rep.ofMulDistribMulAction M G).ρ g) a = Additive.ofMul (g • Additive.toMul a)

full_name: Rep.ofAlgebraAutOnUnits
code: /-- Given an `R`-algebra `S`, the `ℤ`-linear representation associated to the natural action of
`S ≃ₐ[R] S` on `Sˣ`. -/
@[simp] def ofAlgebraAutOnUnits (R S : Type) [CommRing R] [CommRing S] [Algebra R S] :
    Rep ℤ (S ≃ₐ[R] S) 
goal: Rep ℤ (S ≃ₐ[R] S)

full_name: Rep.leftRegularHom
code: /-- Given an element `x : A`, there is a natural morphism of representations `k[G] ⟶ A` sending
`g ↦ A.ρ(g)(x).` -/
@[simps]
noncomputable def leftRegularHom (A : Rep k G) (x : A) : Rep.ofMulAction k G G ⟶ A 
goal: Rep.ofMulAction k G G ⟶ A

full_name: Rep.leftRegularHom_hom
code: /-- Given an element `x : A`, there is a natural morphism of representations `k[G] ⟶ A` sending
`g ↦ A.ρ(g)(x).` -/
@[simps]
noncomputable def leftRegularHom (A : Rep k G) (x : A) : Rep.ofMulAction k G G ⟶ A 
goal: (A.leftRegularHom x).hom = (Finsupp.lift (↑A.V) k G) fun g => (A.ρ g) x

full_name: Rep.leftRegularHom_apply
code: theorem leftRegularHom_apply {A : Rep k G} (x : A) :
    (leftRegularHom A x).hom (Finsupp.single 1 1) = x 
goal: (A.leftRegularHom x).hom (Finsupp.single 1 1) = x

full_name: Rep.leftRegularHomEquiv_apply
code: /-- Given a `k`-linear `G`-representation `A`, there is a `k`-linear isomorphism between
representation morphisms `Hom(k[G], A)` and `A`. -/
@[simps]
noncomputable def leftRegularHomEquiv (A : Rep k G) : (Rep.ofMulAction k G G ⟶ A) ≃ₗ[k] A 
goal: A.leftRegularHomEquiv f = f.hom (Finsupp.single 1 1)

full_name: Rep.leftRegularHomEquiv
code: /-- Given a `k`-linear `G`-representation `A`, there is a `k`-linear isomorphism between
representation morphisms `Hom(k[G], A)` and `A`. -/
@[simps]
noncomputable def leftRegularHomEquiv (A : Rep k G) : (Rep.ofMulAction k G G ⟶ A) ≃ₗ[k] A 
goal: (Rep.ofMulAction k G G ⟶ A) ≃ₗ[k] CoeSort.coe A

full_name: Rep.leftRegularHomEquiv_symm_apply
code: /-- Given a `k`-linear `G`-representation `A`, there is a `k`-linear isomorphism between
representation morphisms `Hom(k[G], A)` and `A`. -/
@[simps]
noncomputable def leftRegularHomEquiv (A : Rep k G) : (Rep.ofMulAction k G G ⟶ A) ≃ₗ[k] A 
goal: A.leftRegularHomEquiv.symm x = A.leftRegularHom x

full_name: Rep.leftRegularHomEquiv_symm_single
code: theorem leftRegularHomEquiv_symm_single {A : Rep k G} (x : A) (g : G) :
    ((leftRegularHomEquiv A).symm x).hom (Finsupp.single g 1) = A.ρ g x 
goal: (A.leftRegularHomEquiv.symm x).hom (Finsupp.single g 1) = (A.ρ g) x

full_name: Rep.ihom_obj
code: /-- Given a `k`-linear `G`-representation `(A, ρ₁)`, this is the 'internal Hom' functor sending
`(B, ρ₂)` to the representation `Homₖ(A, B)` that maps `g : G` and `f : A →ₗ[k] B` to
`(ρ₂ g) ∘ₗ f ∘ₗ (ρ₁ g⁻¹)`. -/
@[simps]
protected def ihom (A : Rep k G) : Rep k G ⥤ Rep k G 
goal: A.ihom.obj B = Rep.of (A.ρ.linHom B.ρ)

full_name: Rep.ihom_map_hom
code: /-- Given a `k`-linear `G`-representation `(A, ρ₁)`, this is the 'internal Hom' functor sending
`(B, ρ₂)` to the representation `Homₖ(A, B)` that maps `g : G` and `f : A →ₗ[k] B` to
`(ρ₂ g) ∘ₗ f ∘ₗ (ρ₁ g⁻¹)`. -/
@[simps]
protected def ihom (A : Rep k G) : Rep k G ⥤ Rep k G 
goal: (A.ihom.map f).hom = ModuleCat.ofHom ((LinearMap.llcomp k (CoeSort.coe A) (CoeSort.coe X) (CoeSort.coe Y)) f.hom)

full_name: Rep.ihom
code: /-- Given a `k`-linear `G`-representation `(A, ρ₁)`, this is the 'internal Hom' functor sending
`(B, ρ₂)` to the representation `Homₖ(A, B)` that maps `g : G` and `f : A →ₗ[k] B` to
`(ρ₂ g) ∘ₗ f ∘ₗ (ρ₁ g⁻¹)`. -/
@[simps]
protected def ihom (A : Rep k G) : Rep k G ⥤ Rep k G 
goal: Rep k G ⥤ Rep k G

full_name: Rep.ihom_obj_ρ_apply
code: @[simp] theorem ihom_obj_ρ_apply {A B : Rep k G} (g : G) (x : A →ₗ[k] B) :
    ((Rep.ihom A).obj B).ρ g x = B.ρ g ∘ₗ x ∘ₗ A.ρ g⁻¹ 
goal: ((A.ihom.obj B).ρ g) x = B.ρ g ∘ₗ x ∘ₗ A.ρ g⁻¹

full_name: Rep.homEquiv
code: /-- Given a `k`-linear `G`-representation `A`, this is the Hom-set bijection in the adjunction
`A ⊗ - ⊣ ihom(A, -)`. It sends `f : A ⊗ B ⟶ C` to a `Rep k G` morphism defined by currying the
`k`-linear map underlying `f`, giving a map `A →ₗ[k] B →ₗ[k] C`, then flipping the arguments. -/
def homEquiv (A B C : Rep k G) : (A ⊗ B ⟶ C) ≃ (B ⟶ (Rep.ihom A).obj C) 
goal: (CategoryTheory.MonoidalCategory.tensorObj A B ⟶ C) ≃ (B ⟶ A.ihom.obj C)

full_name: Rep.homEquiv_apply_hom
code: /-- Porting note: if we generate this with `@[simps]` the linter complains some types in the LHS
simplify. -/
theorem homEquiv_apply_hom (f : A ⊗ B ⟶ C) :
    (homEquiv A B C f).hom = (TensorProduct.curry f.hom).flip 
goal: ((A.homEquiv B C) f).hom = (TensorProduct.curry f.hom).flip

full_name: Rep.homEquiv_symm_apply_hom
code: /-- Porting note: if we generate this with `@[simps]` the linter complains some types in the LHS
simplify. -/
theorem homEquiv_symm_apply_hom (f : B ⟶ (Rep.ihom A).obj C) :
    ((homEquiv A B C).symm f).hom = TensorProduct.uncurry k A B C f.hom.flip 
goal: ((A.homEquiv B C).symm f).hom =
  (TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe B) (CoeSort.coe C)) (LinearMap.flip f.hom)

full_name: Rep.instMonoidalClosed
code: instance : MonoidalClosed (Rep k G) 
goal: CategoryTheory.MonoidalClosed (Rep k G)

full_name: Rep.ihom_obj_ρ_def
code: @[simp]
theorem ihom_obj_ρ_def (A B : Rep k G) : ((ihom A).obj B).ρ = ((Rep.ihom A).obj B).ρ 
goal: ((CategoryTheory.ihom A).obj B).ρ = (A.ihom.obj B).ρ

full_name: Rep.homEquiv_def
code: @[simp]
theorem homEquiv_def (A B C : Rep k G) : (ihom.adjunction A).homEquiv B C = Rep.homEquiv A B C 
goal: (CategoryTheory.ihom.adjunction A).homEquiv B C = A.homEquiv B C

full_name: Rep.ihom_ev_app_hom
code: @[simp]
theorem ihom_ev_app_hom (A B : Rep k G) :
    Action.Hom.hom ((ihom.ev A).app B)
      = TensorProduct.uncurry k A (A →ₗ[k] B) B LinearMap.id.flip 
goal: ((CategoryTheory.ihom.ev A).app B).hom =
  (TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe A →ₗ[k] CoeSort.coe B) (CoeSort.coe B)) LinearMap.id.flip

full_name: Rep.ihom_coev_app_hom
code: @[simp] theorem ihom_coev_app_hom (A B : Rep k G) :
    Action.Hom.hom ((ihom.coev A).app B) = (TensorProduct.mk k _ _).flip 
goal: ((CategoryTheory.ihom.coev A).app B).hom = (TensorProduct.mk k (CoeSort.coe A) ↑((𝟭 (Rep k G)).obj B).V).flip

full_name: Rep.MonoidalClosed.linearHomEquiv
code: /-- There is a `k`-linear isomorphism between the sets of representation morphisms`Hom(A ⊗ B, C)`
and `Hom(B, Homₖ(A, C))`. -/
def MonoidalClosed.linearHomEquiv : (A ⊗ B ⟶ C) ≃ₗ[k] B ⟶ A ⟶[Rep k G] C 
goal: (CategoryTheory.MonoidalCategory.tensorObj A B ⟶ C) ≃ₗ[k] B ⟶ (CategoryTheory.ihom A).obj C

full_name: Rep.MonoidalClosed.linearHomEquivComm
code: /-- There is a `k`-linear isomorphism between the sets of representation morphisms`Hom(A ⊗ B, C)`
and `Hom(A, Homₖ(B, C))`. -/
def MonoidalClosed.linearHomEquivComm : (A ⊗ B ⟶ C) ≃ₗ[k] A ⟶ B ⟶[Rep k G] C 
goal: (CategoryTheory.MonoidalCategory.tensorObj A B ⟶ C) ≃ₗ[k] A ⟶ (CategoryTheory.ihom B).obj C

full_name: Rep.MonoidalClosed.linearHomEquiv_hom
code: @[simp, nolint simpNF]
theorem MonoidalClosed.linearHomEquiv_hom (f : A ⊗ B ⟶ C) :
    (MonoidalClosed.linearHomEquiv A B C f).hom = (TensorProduct.curry f.hom).flip 
goal: ((Rep.MonoidalClosed.linearHomEquiv A B C) f).hom = (TensorProduct.curry f.hom).flip

full_name: Rep.MonoidalClosed.linearHomEquivComm_hom
code: @[simp, nolint simpNF]
theorem MonoidalClosed.linearHomEquivComm_hom (f : A ⊗ B ⟶ C) :
    (MonoidalClosed.linearHomEquivComm A B C f).hom = TensorProduct.curry f.hom 
goal: ((Rep.MonoidalClosed.linearHomEquivComm A B C) f).hom = TensorProduct.curry f.hom

full_name: Rep.MonoidalClosed.linearHomEquiv_symm_hom
code: theorem MonoidalClosed.linearHomEquiv_symm_hom (f : B ⟶ A ⟶[Rep k G] C) :
    ((MonoidalClosed.linearHomEquiv A B C).symm f).hom = TensorProduct.uncurry k A B C f.hom.flip 
goal: ((Rep.MonoidalClosed.linearHomEquiv A B C).symm f).hom =
  (TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe B) (CoeSort.coe C)) (LinearMap.flip f.hom)

full_name: Rep.MonoidalClosed.linearHomEquivComm_symm_hom
code: theorem MonoidalClosed.linearHomEquivComm_symm_hom (f : A ⟶ B ⟶[Rep k G] C) :
    ((MonoidalClosed.linearHomEquivComm A B C).symm f).hom
      = TensorProduct.uncurry k A B C f.hom 
goal: ((Rep.MonoidalClosed.linearHomEquivComm A B C).symm f).hom =
  (TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe B) (CoeSort.coe C)) f.hom

full_name: Representation.repOfTprodIso
code: /-- Tautological isomorphism to help Lean in typechecking. -/
def repOfTprodIso : Rep.of (ρ.tprod τ) ≅ Rep.of ρ ⊗ Rep.of τ 
goal: Rep.of (ρ.tprod τ) ≅ CategoryTheory.MonoidalCategory.tensorObj (Rep.of ρ) (Rep.of τ)

full_name: Representation.repOfTprodIso_apply
code: theorem repOfTprodIso_apply (x : TensorProduct k V W) : (repOfTprodIso ρ τ).hom.hom x = x 
goal: (ρ.repOfTprodIso τ).hom.hom x = x

full_name: Representation.repOfTprodIso_inv_apply
code: theorem repOfTprodIso_inv_apply (x : TensorProduct k V W) : (repOfTprodIso ρ τ).inv.hom x = x 
goal: (ρ.repOfTprodIso τ).inv.hom x = x

full_name: Rep.to_Module_monoidAlgebra_map_aux
code: /-- Auxiliary lemma for `toModuleMonoidAlgebra`. -/
theorem to_Module_monoidAlgebra_map_aux {k G : Type*} [CommRing k] [Monoid G] (V W : Type*)
    [AddCommGroup V] [AddCommGroup W] [Module k V] [Module k W] (ρ : G →* V →ₗ[k] V)
    (σ : G →* W →ₗ[k] W) (f : V →ₗ[k] W) (w : ∀ g : G, f.comp (ρ g) = (σ g).comp f)
    (r : MonoidAlgebra k G) (x : V) :
    f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) r) x) =
      (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) r) (f x) 
goal: f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) r) x) = (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) r) (f x)

full_name: Rep.toModuleMonoidAlgebraMap
code: /-- Auxiliary definition for `toModuleMonoidAlgebra`. -/
def toModuleMonoidAlgebraMap {V W : Rep k G} (f : V ⟶ W) :
    ModuleCat.of (MonoidAlgebra k G) V.ρ.asModule ⟶ ModuleCat.of (MonoidAlgebra k G) W.ρ.asModule 
goal: ModuleCat.of (MonoidAlgebra k G) V.ρ.asModule ⟶ ModuleCat.of (MonoidAlgebra k G) W.ρ.asModule

full_name: Rep.toModuleMonoidAlgebra
code: /-- Functorially convert a representation of `G` into a module over `MonoidAlgebra k G`. -/
def toModuleMonoidAlgebra : Rep k G ⥤ ModuleCat.{u} (MonoidAlgebra k G) 
goal: Rep k G ⥤ ModuleCat (MonoidAlgebra k G)

full_name: Rep.ofModuleMonoidAlgebra
code: /-- Functorially convert a module over `MonoidAlgebra k G` into a representation of `G`. -/
def ofModuleMonoidAlgebra : ModuleCat.{u} (MonoidAlgebra k G) ⥤ Rep k G 
goal: ModuleCat (MonoidAlgebra k G) ⥤ Rep k G

full_name: Rep.ofModuleMonoidAlgebra_obj_coe
code: theorem ofModuleMonoidAlgebra_obj_coe (M : ModuleCat.{u} (MonoidAlgebra k G)) :
    (ofModuleMonoidAlgebra.obj M : Type u) = RestrictScalars k (MonoidAlgebra k G) M 
goal: CoeSort.coe (Rep.ofModuleMonoidAlgebra.obj M) = RestrictScalars k (MonoidAlgebra k G) ↑M

full_name: Rep.ofModuleMonoidAlgebra_obj_ρ
code: theorem ofModuleMonoidAlgebra_obj_ρ (M : ModuleCat.{u} (MonoidAlgebra k G)) :
    (ofModuleMonoidAlgebra.obj M).ρ = Representation.ofModule M 
goal: (Rep.ofModuleMonoidAlgebra.obj M).ρ = Representation.ofModule ↑M

full_name: Rep.counitIsoAddEquiv
code: /-- Auxiliary definition for `equivalenceModuleMonoidAlgebra`. -/
def counitIsoAddEquiv {M : ModuleCat.{u} (MonoidAlgebra k G)} :
    (ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M ≃+ M 
goal: ↑((Rep.ofModuleMonoidAlgebra ⋙ Rep.toModuleMonoidAlgebra).obj M) ≃+ ↑M

full_name: Rep.unitIsoAddEquiv
code: /-- Auxiliary definition for `equivalenceModuleMonoidAlgebra`. -/
def unitIsoAddEquiv {V : Rep k G} : V ≃+ (toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V 
goal: CoeSort.coe V ≃+ CoeSort.coe ((Rep.toModuleMonoidAlgebra ⋙ Rep.ofModuleMonoidAlgebra).obj V)

full_name: Rep.counitIso
code: /-- Auxiliary definition for `equivalenceModuleMonoidAlgebra`. -/
def counitIso (M : ModuleCat.{u} (MonoidAlgebra k G)) :
    (ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M ≅ M 
goal: (Rep.ofModuleMonoidAlgebra ⋙ Rep.toModuleMonoidAlgebra).obj M ≅ M

full_name: Rep.unit_iso_comm
code: theorem unit_iso_comm (V : Rep k G) (g : G) (x : V) :
    unitIsoAddEquiv ((V.ρ g).toFun x) = ((ofModuleMonoidAlgebra.obj
      (toModuleMonoidAlgebra.obj V)).ρ g).toFun (unitIsoAddEquiv x) 
goal: Rep.unitIsoAddEquiv ((V.ρ g).toFun x) =
  ((Rep.ofModuleMonoidAlgebra.obj (Rep.toModuleMonoidAlgebra.obj V)).ρ g).toFun (Rep.unitIsoAddEquiv x)

full_name: Rep.unitIso
code: /-- Auxiliary definition for `equivalenceModuleMonoidAlgebra`. -/
def unitIso (V : Rep k G) : V ≅ (toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V 
goal: V ≅ (Rep.toModuleMonoidAlgebra ⋙ Rep.ofModuleMonoidAlgebra).obj V

full_name: Rep.equivalenceModuleMonoidAlgebra
code: /-- The categorical equivalence `Rep k G ≌ ModuleCat (MonoidAlgebra k G)`. -/
def equivalenceModuleMonoidAlgebra : Rep k G ≌ ModuleCat.{u} (MonoidAlgebra k G) 
goal: Rep k G ≌ ModuleCat (MonoidAlgebra k G)