l3lab/ntp-mathlib huggingface dataset:
theorem ofMulAction_self_smul_eq_mul (x : MonoidAlgebra k G) (y : (ofMulAction k G G).asModule) :
    x • y = (x * y : MonoidAlgebra k G) := -- by
  -- Porting note: trouble figuring out the motive
  x.induction_on (p := fun z => z • y = z * y)
    (fun g => by
      show asAlgebraHom (ofMulAction k G G) _ _ = _; ext;
      simp only [MonoidAlgebra.of_apply, asAlgebraHom_single, one_smul,
        ofMulAction_apply, smul_eq_mul]
      -- Porting note : single_mul_apply not firing in simp
      rw [MonoidAlgebra.single_mul_apply, one_mul]
    )
    (fun x y hx hy => by simp only [hx, hy, add_mul, add_smul]) fun r x hx => by
    show asAlgebraHom (ofMulAction k G G) _ _ = _  -- Porting note: was simpa [← hx]
    

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Group G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
x✝ : MonoidAlgebra k G
y : asModule (ofMulAction k G G)
r : k
x : MonoidAlgebra k G
hx : (fun z => z • y = z * y) x
⊢ ((asAlgebraHom (ofMulAction k G G)) (r • x)) y = r • x * y

Next tactic:
simp only [map_smul, smul_apply, Algebra.smul_mul_assoc]
theorem ofMulAction_self_smul_eq_mul (x : MonoidAlgebra k G) (y : (ofMulAction k G G).asModule) :
    x • y = (x * y : MonoidAlgebra k G) := -- by
  -- Porting note: trouble figuring out the motive
  x.induction_on (p := fun z => z • y = z * y)
    (fun g => by
      show asAlgebraHom (ofMulAction k G G) _ _ = _; ext;
      simp only [MonoidAlgebra.of_apply, asAlgebraHom_single, one_smul,
        ofMulAction_apply, smul_eq_mul]
      -- Porting note : single_mul_apply not firing in simp
      rw [MonoidAlgebra.single_mul_apply, one_mul]
    )
    (fun x y hx hy => by simp only [hx, hy, add_mul, add_smul]) fun r x hx => by
    show asAlgebraHom (ofMulAction k G G) _ _ = _  -- Porting note: was simpa [← hx]
    simp only [map_smul, smul_apply, Algebra.smul_mul_assoc]
    

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Group G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
x✝ : MonoidAlgebra k G
y : asModule (ofMulAction k G G)
r : k
x : MonoidAlgebra k G
hx : (fun z => z • y = z * y) x
⊢ r • ((asAlgebraHom (ofMulAction k G G)) x) y = r • (x * y)

Next tactic:
rw [← hx]
theorem ofMulAction_self_smul_eq_mul (x : MonoidAlgebra k G) (y : (ofMulAction k G G).asModule) :
    x • y = (x * y : MonoidAlgebra k G) := -- by
  -- Porting note: trouble figuring out the motive
  x.induction_on (p := fun z => z • y = z * y)
    (fun g => by
      show asAlgebraHom (ofMulAction k G G) _ _ = _; ext;
      simp only [MonoidAlgebra.of_apply, asAlgebraHom_single, one_smul,
        ofMulAction_apply, smul_eq_mul]
      -- Porting note : single_mul_apply not firing in simp
      rw [MonoidAlgebra.single_mul_apply, one_mul]
    )
    (fun x y hx hy => by simp only [hx, hy, add_mul, add_smul]) fun r x hx => by
    show asAlgebraHom (ofMulAction k G G) _ _ = _  -- Porting note: was simpa [← hx]
    simp only [map_smul, smul_apply, Algebra.smul_mul_assoc]
    rw [← hx]
    

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Group G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
x✝ : MonoidAlgebra k G
y : asModule (ofMulAction k G G)
r : k
x : MonoidAlgebra k G
hx : (fun z => z • y = z * y) x
⊢ r • ((asAlgebraHom (ofMulAction k G G)) x) y = r • x • y

Next tactic:
rfl
theorem asGroupHom_apply (g : G) : ↑(asGroupHom ρ g) = ρ g := by
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Group G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
⊢ ↑((asGroupHom ρ) g) = ρ g

Next tactic:
simp only [asGroupHom, MonoidHom.coe_toHomUnits]
/-- 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) where
  toFun g := TensorProduct.map (ρV g) (ρW g)
  map_one' := by 

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
⊢ (fun g => map (ρV g) (ρW g)) 1 = 1

Next tactic:
simp only [_root_.map_one, TensorProduct.map_one]
/-- 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) where
  toFun g := TensorProduct.map (ρV g) (ρW g)
  map_one' := by simp only [_root_.map_one, TensorProduct.map_one]
  map_mul' g h := by 

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g h : G
⊢ OneHom.toFun { toFun := fun g => map (ρV g) (ρW g), map_one' := (_ : map (ρV 1) (ρW 1) = 1) } (g * h) =
    OneHom.toFun { toFun := fun g => map (ρV g) (ρW g), map_one' := (_ : map (ρV 1) (ρW 1) = 1) } g *
      OneHom.toFun { toFun := fun g => map (ρV g) (ρW g), map_one' := (_ : map (ρV 1) (ρW 1) = 1) } h

Next tactic:
simp only [_root_.map_mul, TensorProduct.map_mul]
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 := by
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ let x' := x;
  let z := x ⊗ₜ[k] y;
  r • z = (r • x') ⊗ₜ[k] y

Next tactic:
show asAlgebraHom (ρV ⊗ 1) _ _ = asAlgebraHom ρV _ _ ⊗ₜ _
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 := by
  show asAlgebraHom (ρV ⊗ 1) _ _ = asAlgebraHom ρV _ _ ⊗ₜ _
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ ((asAlgebraHom (ρV ⊗ 1)) r) (x ⊗ₜ[k] y) = ((asAlgebraHom ρV) r) x ⊗ₜ[k] y

Next tactic:
simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
    LinearMap.finsupp_sum_apply, LinearMap.smul_apply, TensorProduct.map_tmul, LinearMap.one_apply]
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 := by
  show asAlgebraHom (ρV ⊗ 1) _ _ = asAlgebraHom ρV _ _ ⊗ₜ _
  simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
    LinearMap.finsupp_sum_apply, LinearMap.smul_apply, TensorProduct.map_tmul, LinearMap.one_apply]
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ (Finsupp.sum r fun i d => d • (ρV i) x ⊗ₜ[k] y) = (Finsupp.sum r fun i d => d • (ρV i) x) ⊗ₜ[k] y

Next tactic:
simp only [Finsupp.sum, TensorProduct.sum_tmul]
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 := by
  show asAlgebraHom (ρV ⊗ 1) _ _ = asAlgebraHom ρV _ _ ⊗ₜ _
  simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
    LinearMap.finsupp_sum_apply, LinearMap.smul_apply, TensorProduct.map_tmul, LinearMap.one_apply]
  simp only [Finsupp.sum, TensorProduct.sum_tmul]
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ (Finset.sum r.support fun x_1 => r x_1 • (ρV x_1) x ⊗ₜ[k] y) = Finset.sum r.support fun a => (r a • (ρV a) x) ⊗ₜ[k] y

Next tactic:
rfl
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') := by
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ let y' := y;
  let z := x ⊗ₜ[k] y;
  r • z = x ⊗ₜ[k] (r • y')

Next tactic:
show asAlgebraHom (1 ⊗ ρW) _ _ = _ ⊗ₜ asAlgebraHom ρW _ _
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') := by
  show asAlgebraHom (1 ⊗ ρW) _ _ = _ ⊗ₜ asAlgebraHom ρW _ _
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ ((asAlgebraHom (1 ⊗ ρW)) r) (x ⊗ₜ[k] y) = x ⊗ₜ[k] ((asAlgebraHom ρW) r) y

Next tactic:
simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
    LinearMap.finsupp_sum_apply, LinearMap.smul_apply, TensorProduct.map_tmul, LinearMap.one_apply]
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') := by
  show asAlgebraHom (1 ⊗ ρW) _ _ = _ ⊗ₜ asAlgebraHom ρW _ _
  simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
    LinearMap.finsupp_sum_apply, LinearMap.smul_apply, TensorProduct.map_tmul, LinearMap.one_apply]
  

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
r : MonoidAlgebra k G
x : V
y : W
⊢ (Finsupp.sum r fun i d => d • x ⊗ₜ[k] (ρW i) y) = x ⊗ₜ[k] Finsupp.sum r fun i d => d • (ρW i) y

Next tactic:
simp only [Finsupp.sum, TensorProduct.tmul_sum, TensorProduct.tmul_smul]
/-- 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) where
  toFun g :=
    { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by 

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
f₁ f₂ : V →ₗ[k] W
⊢ (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) (f₁ + f₂) = (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₁ + (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₂

Next tactic:
simp_rw [add_comp, comp_add]
/-- 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) where
  toFun g :=
    { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp_rw [add_comp, comp_add]
      map_smul' := fun r f => by 

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
r : k
f : V →ₗ[k] W
⊢ AddHom.toFun
      { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹,
        map_add' :=
          (_ :
            ∀ (f₁ f₂ : V →ₗ[k] W),
              (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) (f₁ + f₂) =
                (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₁ + (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₂) }
      (r • f) =
    (RingHom.id k) r •
      AddHom.toFun
        { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹,
          map_add' :=
            (_ :
              ∀ (f₁ f₂ : V →ₗ[k] W),
                (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) (f₁ + f₂) =
                  (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₁ + (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₂) }
        f

Next tactic:
simp_rw [RingHom.id_apply, smul_comp, comp_smul]
/-- 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) where
  toFun g :=
    { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp_rw [add_comp, comp_add]
      map_smul' := fun r f => by simp_rw [RingHom.id_apply, smul_comp, comp_smul] }
  map_one' :=
    LinearMap.ext fun x => by
      

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
x : V →ₗ[k] W
⊢ ((fun g =>
          {
            toAddHom :=
              { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹,
                map_add' :=
                  (_ :
                    ∀ (f₁ f₂ : V →ₗ[k] W),
                      (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) (f₁ + f₂) =
                        (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₁ + (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₂) },
            map_smul' :=
              (_ :
                ∀ (r : k) (f : V →ₗ[k] W),
                  AddHom.toFun
                      { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹,
                        map_add' :=
                          (_ :
                            ∀ (f₁ f₂ : V →ₗ[k] W),
                              (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) (f₁ + f₂) =
                                (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₁ + (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₂) }
                      (r • f) =
                    (RingHom.id k) r •
                      AddHom.toFun
                        { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹,
                          map_add' :=
                            (_ :
                              ∀ (f₁ f₂ : V →ₗ[k] W),
                                (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) (f₁ + f₂) =
                                  (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₁ + (fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹) f₂) }
                        f) })
        1)
      x =
    1 x

Next tactic:
dsimp
/-- 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) where
  toFun g :=
    { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp_rw [add_comp, comp_add]
      map_smul' := fun r f => by simp_rw [RingHom.id_apply, smul_comp, comp_smul] }
  map_one' :=
    LinearMap.ext fun x => by
      dsimp -- Porting note: now needed
      

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
x : V →ₗ[k] W
⊢ ρW 1 ∘ₗ x ∘ₗ ρV 1⁻¹ = x

Next tactic:
simp_rw [inv_one, map_one, one_eq_id, comp_id, id_comp]
/-- 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) where
  toFun g :=
    { toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp_rw [add_comp, comp_add]
      map_smul' := fun r f => by simp_rw [RingHom.id_apply, smul_comp, comp_smul] }
  map_one' :=
    LinearMap.ext fun x => by
      dsimp -- Porting note: now needed
      simp_rw [inv_one, map_one, one_eq_id, comp_id, id_comp]
  map_mul' g h :=
    LinearMap.ext fun x => by
      dsimp -- Porting note: now needed
      

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g h : G
x : V →ₗ[k] W
⊢ ρW (g * h) ∘ₗ x ∘ₗ ρV (g * h)⁻¹ = ρW g ∘ₗ (ρW h ∘ₗ x ∘ₗ ρV h⁻¹) ∘ₗ ρV g⁻¹

Next tactic:
simp_rw [mul_inv_rev, map_mul, mul_eq_comp, comp_assoc]
/-- 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) where
  toFun g :=
    { toFun := fun f => f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by 

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
f₁ f₂ : Module.Dual k V
⊢ (fun f => f ∘ₗ ρV g⁻¹) (f₁ + f₂) = (fun f => f ∘ₗ ρV g⁻¹) f₁ + (fun f => f ∘ₗ ρV g⁻¹) f₂

Next tactic:
simp only [add_comp]
/-- 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) where
  toFun g :=
    { toFun := fun f => f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp only [add_comp]
      map_smul' := fun r f => by
        

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
r : k
f : Module.Dual k V
⊢ AddHom.toFun
      { toFun := fun f => f ∘ₗ ρV g⁻¹,
        map_add' := (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
      (r • f) =
    (RingHom.id k) r •
      AddHom.toFun
        { toFun := fun f => f ∘ₗ ρV g⁻¹,
          map_add' := (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
        f

Next tactic:
ext
/-- 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) where
  toFun g :=
    { toFun := fun f => f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp only [add_comp]
      map_smul' := fun r f => by
        ext
        

Proof state:
case h
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
r : k
f : Module.Dual k V
x✝ : V
⊢ (AddHom.toFun
        { toFun := fun f => f ∘ₗ ρV g⁻¹,
          map_add' := (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
        (r • f))
      x✝ =
    ((RingHom.id k) r •
        AddHom.toFun
          { toFun := fun f => f ∘ₗ ρV g⁻¹,
            map_add' := (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
          f)
      x✝

Next tactic:
simp only [coe_comp, Function.comp_apply, smul_apply, RingHom.id_apply]
/-- 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) where
  toFun g :=
    { toFun := fun f => f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp only [add_comp]
      map_smul' := fun r f => by
        ext
        simp only [coe_comp, Function.comp_apply, smul_apply, RingHom.id_apply] }
  map_one' := by
    

Proof state:
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
⊢ (fun g =>
        {
          toAddHom :=
            { toFun := fun f => f ∘ₗ ρV g⁻¹,
              map_add' :=
                (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) },
          map_smul' :=
            (_ :
              ∀ (r : k) (f : Module.Dual k V),
                AddHom.toFun
                    { toFun := fun f => f ∘ₗ ρV g⁻¹,
                      map_add' :=
                        (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
                    (r • f) =
                  (RingHom.id k) r •
                    AddHom.toFun
                      { toFun := fun f => f ∘ₗ ρV g⁻¹,
                        map_add' :=
                          (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
                      f) })
      1 =
    1

Next tactic:
ext
/-- 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) where
  toFun g :=
    { toFun := fun f => f ∘ₗ ρV g⁻¹
      map_add' := fun f₁ f₂ => by simp only [add_comp]
      map_smul' := fun r f => by
        ext
        simp only [coe_comp, Function.comp_apply, smul_apply, RingHom.id_apply] }
  map_one' := by
    ext
    

Proof state:
case h.h
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
x✝¹ : Module.Dual k V
x✝ : V
⊢ (((fun g =>
            {
              toAddHom :=
                { toFun := fun f => f ∘ₗ ρV g⁻¹,
                  map_add' :=
                    (_ : ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) },
              map_smul' :=
                (_ :
                  ∀ (r : k) (f : Module.Dual k V),
                    AddHom.toFun
                        { toFun := fun f => f ∘ₗ ρV g⁻¹,
                          map_add' :=
                            (_ :
                              ∀ (f₁ f₂ : Module.Dual k V), f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
                        (r • f) =
                      (RingHom.id k) r •
                        AddHom.toFun
                          { toFun := fun f => f ∘ₗ ρV g⁻¹,
                            map_add' :=
                              (_ :
                                ∀ (f₁ f₂ : Module.Dual k V),
                                  f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹ = f₁ ∘ₗ ρV g⁻¹ + f₂ ∘ₗ ρV g⁻¹) }
                          f) })
          1)
        x✝¹)
      x✝ =
    (1 x✝¹) x✝

Next tactic:
dsimp