/-- Composing an alternating map with a linear map on the left gives again an alternating map. -/
def compAlternatingMap (g : N →ₗ[R] N₂) : (M [Λ^ι]→ₗ[R] N) →+ (M [Λ^ι]→ₗ[R] N₂) where
  toFun f :=
    { g.compMultilinearMap (f : MultilinearMap R (fun _ : ι => M) N) with
      map_eq_zero_of_eq' := fun v i j h hij => by simp [f.map_eq_zero_of_eq v h hij] }
  map_zero' := by
    ext
    simp
  map_add' a b := by
    ext
    

Proof state:
case H
R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
N₂ : Type u_10
inst✝¹ : AddCommMonoid N₂
inst✝ : Module R N₂
g : N →ₗ[R] N₂
a b : M [Λ^ι]→ₗ[R] N
x✝ : ι → M
⊢ (ZeroHom.toFun
        {
          toFun := fun f =>
            let src := compMultilinearMap g ↑f;
            {
              toMultilinearMap :=
                { toFun := src.toFun,
                  map_add' :=
                    (_ :
                      ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                        MultilinearMap.toFun src (Function.update m i (x + y)) =
                          MultilinearMap.toFun src (Function.update m i x) +
                            MultilinearMap.toFun src (Function.update m i y)),
                  map_smul' :=
                    (_ :
                      ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                        MultilinearMap.toFun src (Function.update m i (c • x)) =
                          c • MultilinearMap.toFun src (Function.update m i x)) },
              map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) },
          map_zero' :=
            (_ :
              (fun f =>
                    let src := compMultilinearMap g ↑f;
                    {
                      toMultilinearMap :=
                        { toFun := src.toFun,
                          map_add' :=
                            (_ :
                              ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                                MultilinearMap.toFun src (Function.update m i (x + y)) =
                                  MultilinearMap.toFun src (Function.update m i x) +
                                    MultilinearMap.toFun src (Function.update m i y)),
                          map_smul' :=
                            (_ :
                              ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                                MultilinearMap.toFun src (Function.update m i (c • x)) =
                                  c • MultilinearMap.toFun src (Function.update m i x)) },
                      map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) })
                  0 =
                0) }
        (a + b))
      x✝ =
    (ZeroHom.toFun
          {
            toFun := fun f =>
              let src := compMultilinearMap g ↑f;
              {
                toMultilinearMap :=
                  { toFun := src.toFun,
                    map_add' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                          MultilinearMap.toFun src (Function.update m i (x + y)) =
                            MultilinearMap.toFun src (Function.update m i x) +
                              MultilinearMap.toFun src (Function.update m i y)),
                    map_smul' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                          MultilinearMap.toFun src (Function.update m i (c • x)) =
                            c • MultilinearMap.toFun src (Function.update m i x)) },
                map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) },
            map_zero' :=
              (_ :
                (fun f =>
                      let src := compMultilinearMap g ↑f;
                      {
                        toMultilinearMap :=
                          { toFun := src.toFun,
                            map_add' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                                  MultilinearMap.toFun src (Function.update m i (x + y)) =
                                    MultilinearMap.toFun src (Function.update m i x) +
                                      MultilinearMap.toFun src (Function.update m i y)),
                            map_smul' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                                  MultilinearMap.toFun src (Function.update m i (c • x)) =
                                    c • MultilinearMap.toFun src (Function.update m i x)) },
                        map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) })
                    0 =
                  0) }
          a +
        ZeroHom.toFun
          {
            toFun := fun f =>
              let src := compMultilinearMap g ↑f;
              {
                toMultilinearMap :=
                  { toFun := src.toFun,
                    map_add' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                          MultilinearMap.toFun src (Function.update m i (x + y)) =
                            MultilinearMap.toFun src (Function.update m i x) +
                              MultilinearMap.toFun src (Function.update m i y)),
                    map_smul' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                          MultilinearMap.toFun src (Function.update m i (c • x)) =
                            c • MultilinearMap.toFun src (Function.update m i x)) },
                map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) },
            map_zero' :=
              (_ :
                (fun f =>
                      let src := compMultilinearMap g ↑f;
                      {
                        toMultilinearMap :=
                          { toFun := src.toFun,
                            map_add' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                                  MultilinearMap.toFun src (Function.update m i (x + y)) =
                                    MultilinearMap.toFun src (Function.update m i x) +
                                      MultilinearMap.toFun src (Function.update m i y)),
                            map_smul' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                                  MultilinearMap.toFun src (Function.update m i (c • x)) =
                                    c • MultilinearMap.toFun src (Function.update m i x)) },
                        map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) })
                    0 =
                  0) }
          b)
      x✝

Next tactic:
simp