/-- 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
      

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
⊢ (OneHom.toFun
        {
          toFun := 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) },
          map_one' :=
            (_ :
              (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 =
                1) }
        (g * h))
      x =
    (OneHom.toFun
          {
            toFun := 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) },
            map_one' :=
              (_ :
                (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 =
                  1) }
          g *
        OneHom.toFun
          {
            toFun := 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) },
            map_one' :=
              (_ :
                (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 =
                  1) }
          h)
      x

Next tactic:
dsimp