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

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
⊢ 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) =
    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

Next tactic:
ext