/-- 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
    dsimp -- Porting note: now needed
    simp only [coe_comp, Function.comp_apply, map_one, inv_one, coe_mk, one_apply]
  map_mul' g h := 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
g h : G
x✝¹ : Module.Dual k V
x✝ : V
⊢ ((OneHom.toFun
          {
            toFun := 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) },
            map_one' :=
              (_ :
                (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) }
          (g * h))
        x✝¹)
      x✝ =
    ((OneHom.toFun
            {
              toFun := 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) },
              map_one' :=
                (_ :
                  (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) }
            g *
          OneHom.toFun
            {
              toFun := 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) },
              map_one' :=
                (_ :
                  (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) }
            h)
        x✝¹)
      x✝

Next tactic:
dsimp