/-- Produce an `AlternatingMap` out of a `MultilinearMap`, by summing over all argument
permutations. -/
def alternatization : MultilinearMap R (fun _ : ι => M) N' →+ M [Λ^ι]→ₗ[R] N' where
  toFun m :=
    { ∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ with
      toFun := ⇑(∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ)
      map_eq_zero_of_eq' := fun v i j hvij hij =>
        alternization_map_eq_zero_of_eq_aux m v i j hij hvij }
  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
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
a b : MultilinearMap R (fun x => M) N'
x✝ : ι → M
⊢ (ZeroHom.toFun
        {
          toFun := fun m =>
            let src := ∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m;
            {
              toMultilinearMap :=
                { toFun := ⇑(∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m),
                  map_add' :=
                    (_ :
                      ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                        toFun src (Function.update m i (x + y)) =
                          toFun src (Function.update m i x) + toFun src (Function.update m i y)),
                  map_smul' :=
                    (_ :
                      ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                        toFun src (Function.update m i (c • x)) = c • toFun src (Function.update m i x)) },
              map_eq_zero_of_eq' :=
                (_ :
                  ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0) },
          map_zero' :=
            (_ :
              (fun m =>
                    let src := ∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m;
                    {
                      toMultilinearMap :=
                        { toFun := ⇑(∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m),
                          map_add' :=
                            (_ :
                              ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                                toFun src (Function.update m i (x + y)) =
                                  toFun src (Function.update m i x) + toFun src (Function.update m i y)),
                          map_smul' :=
                            (_ :
                              ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                                toFun src (Function.update m i (c • x)) = c • toFun src (Function.update m i x)) },
                      map_eq_zero_of_eq' :=
                        (_ :
                          ∀ (v : ι → M) (i j : ι),
                            v i = v j → i ≠ j → (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0) })
                  0 =
                0) }
        (a + b))
      x✝ =
    (ZeroHom.toFun
          {
            toFun := fun m =>
              let src := ∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m;
              {
                toMultilinearMap :=
                  { toFun := ⇑(∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m),
                    map_add' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                          toFun src (Function.update m i (x + y)) =
                            toFun src (Function.update m i x) + toFun src (Function.update m i y)),
                    map_smul' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                          toFun src (Function.update m i (c • x)) = c • toFun src (Function.update m i x)) },
                map_eq_zero_of_eq' :=
                  (_ :
                    ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0) },
            map_zero' :=
              (_ :
                (fun m =>
                      let src := ∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m;
                      {
                        toMultilinearMap :=
                          { toFun := ⇑(∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m),
                            map_add' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                                  toFun src (Function.update m i (x + y)) =
                                    toFun src (Function.update m i x) + toFun src (Function.update m i y)),
                            map_smul' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                                  toFun src (Function.update m i (c • x)) = c • toFun src (Function.update m i x)) },
                        map_eq_zero_of_eq' :=
                          (_ :
                            ∀ (v : ι → M) (i j : ι),
                              v i = v j → i ≠ j → (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0) })
                    0 =
                  0) }
          a +
        ZeroHom.toFun
          {
            toFun := fun m =>
              let src := ∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m;
              {
                toMultilinearMap :=
                  { toFun := ⇑(∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m),
                    map_add' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                          toFun src (Function.update m i (x + y)) =
                            toFun src (Function.update m i x) + toFun src (Function.update m i y)),
                    map_smul' :=
                      (_ :
                        ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                          toFun src (Function.update m i (c • x)) = c • toFun src (Function.update m i x)) },
                map_eq_zero_of_eq' :=
                  (_ :
                    ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0) },
            map_zero' :=
              (_ :
                (fun m =>
                      let src := ∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m;
                      {
                        toMultilinearMap :=
                          { toFun := ⇑(∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m),
                            map_add' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                                  toFun src (Function.update m i (x + y)) =
                                    toFun src (Function.update m i x) + toFun src (Function.update m i y)),
                            map_smul' :=
                              (_ :
                                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                                  toFun src (Function.update m i (c • x)) = c • toFun src (Function.update m i x)) },
                        map_eq_zero_of_eq' :=
                          (_ :
                            ∀ (v : ι → M) (i j : ι),
                              v i = v j → i ≠ j → (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0) })
                    0 =
                  0) }
          b)
      x✝

Next tactic:
simp only [mk_coe, AlternatingMap.coe_mk, sum_apply, smul_apply, domDomCongr_apply, add_apply,
      smul_add, Finset.sum_add_distrib, AlternatingMap.add_apply]