/-- Constructing a linear map `(⨂[R] i, s i) → E` given a `MultilinearMap R s E` with the
property that its composition with the canonical `MultilinearMap R s E` is
the given multilinear map `φ`. -/
def lift : MultilinearMap R s E ≃ₗ[R] (⨂[R] i, s i) →ₗ[R] E where
  toFun φ := { liftAux φ with map_smul' := liftAux.smul }
  invFun φ' := φ'.compMultilinearMap (tprod R)
  left_inv φ := by
    ext
    

Proof state:
case H
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
x✝ : (i : ι) → s i
⊢ ((fun φ' => LinearMap.compMultilinearMap φ' (tprod R))
        (AddHom.toFun
          {
              toAddHom :=
                {
                  toFun := fun φ =>
                    let src := liftAux φ;
                    {
                      toAddHom :=
                        { toFun := src.toFun,
                          map_add' :=
                            (_ :
                              ∀ (x y : ⨂[R] (i : ι), s i),
                                ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                      map_smul' := (_ : ∀ (r : R) (x : ⨂[R] (i : ι), s i), (liftAux φ) (r • x) = r • (liftAux φ) x) },
                  map_add' :=
                    (_ :
                      ∀ (φ₁ φ₂ : MultilinearMap R s E),
                        (fun φ =>
                              let src := liftAux φ;
                              {
                                toAddHom :=
                                  { toFun := src.toFun,
                                    map_add' :=
                                      (_ :
                                        ∀ (x y : ⨂[R] (i : ι), s i),
                                          ZeroHom.toFun (↑src) (x + y) =
                                            ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                map_smul' :=
                                  (_ : ∀ (r : R) (x : ⨂[R] (i : ι), s i), (liftAux φ) (r • x) = r • (liftAux φ) x) })
                            (φ₁ + φ₂) =
                          (fun φ =>
                                let src := liftAux φ;
                                {
                                  toAddHom :=
                                    { toFun := src.toFun,
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : ⨂[R] (i : ι), s i),
                                            ZeroHom.toFun (↑src) (x + y) =
                                              ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                  map_smul' :=
                                    (_ : ∀ (r : R) (x : ⨂[R] (i : ι), s i), (liftAux φ) (r • x) = r • (liftAux φ) x) })
                              φ₁ +
                            (fun φ =>
                                let src := liftAux φ;
                                {
                                  toAddHom :=
                                    { toFun := src.toFun,
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : ⨂[R] (i : ι), s i),
                                            ZeroHom.toFun (↑src) (x + y) =
                                              ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                  map_smul' :=
                                    (_ : ∀ (r : R) (x : ⨂[R] (i : ι), s i), (liftAux φ) (r • x) = r • (liftAux φ) x) })
                              φ₂) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (φ₂ : MultilinearMap R s E),
                    AddHom.toFun
                        {
                          toFun := fun φ =>
                            let src := liftAux φ;
                            {
                              toAddHom :=
                                { toFun := src.toFun,
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : ⨂[R] (i : ι), s i),
                                        ZeroHom.toFun (↑src) (x + y) =
                                          ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                              map_smul' :=
                                (_ : ∀ (r : R) (x : ⨂[R] (i : ι), s i), (liftAux φ) (r • x) = r • (liftAux φ) x) },
                          map_add' :=
                            (_ :
                              ∀ (φ₁ φ₂ : MultilinearMap R s E),
                                (fun φ =>
                                      let src := liftAux φ;
                                      {
                                        toAddHom :=
                                          { toFun := src.toFun,
                                            map_add' :=
                                              (_ :
                                                ∀ (x y : ⨂[R] (i : ι), s i),
                                                  ZeroHom.toFun (↑src) (x + y) =
                                                    ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                        map_smul' :=
                                          (_ :
                                            ∀ (r : R) (x : ⨂[R] (i : ι), s i),
                                              (liftAux φ) (r • x) = r • (liftAux φ) x) })
                                    (φ₁ + φ₂) =
                                  (fun φ =>
                                        let src := liftAux φ;
                                        {
                                          toAddHom :=
                                            { toFun := src.toFun,
                                              map_add' :=
                                                (_ :
                                                  ∀ (x y : ⨂[R] (i : ι), s i),
                                                    ZeroHom.toFun (↑src) (x + y) =
                                                      ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (x : ⨂[R] (i : ι), s i),
                                                (liftAux φ) (r • x) = r • (liftAux φ) x) })
                                      φ₁ +
                                    (fun φ =>
                                        let src := liftAux φ;
                                        {
                                          toAddHom :=
                                            { toFun := src.toFun,
                                              map_add' :=
                                                (_ :
                                                  ∀ (x y : ⨂[R] (i : ι), s i),
                                                    ZeroHom.toFun (↑src) (x + y) =
                                                      ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (x : ⨂[R] (i : ι), s i),
                                                (liftAux φ) (r • x) = r • (liftAux φ) x) })
                                      φ₂) }
                        (r • φ₂) =
                      (RingHom.id R) r •
                        AddHom.toFun
                          {
                            toFun := fun φ =>
                              let src := liftAux φ;
                              {
                                toAddHom :=
                                  { toFun := src.toFun,
                                    map_add' :=
                                      (_ :
                                        ∀ (x y : ⨂[R] (i : ι), s i),
                                          ZeroHom.toFun (↑src) (x + y) =
                                            ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                map_smul' :=
                                  (_ : ∀ (r : R) (x : ⨂[R] (i : ι), s i), (liftAux φ) (r • x) = r • (liftAux φ) x) },
                            map_add' :=
                              (_ :
                                ∀ (φ₁ φ₂ : MultilinearMap R s E),
                                  (fun φ =>
                                        let src := liftAux φ;
                                        {
                                          toAddHom :=
                                            { toFun := src.toFun,
                                              map_add' :=
                                                (_ :
                                                  ∀ (x y : ⨂[R] (i : ι), s i),
                                                    ZeroHom.toFun (↑src) (x + y) =
                                                      ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                          map_smul' :=
                                            (_ :
                                              ∀ (r : R) (x : ⨂[R] (i : ι), s i),
                                                (liftAux φ) (r • x) = r • (liftAux φ) x) })
                                      (φ₁ + φ₂) =
                                    (fun φ =>
                                          let src := liftAux φ;
                                          {
                                            toAddHom :=
                                              { toFun := src.toFun,
                                                map_add' :=
                                                  (_ :
                                                    ∀ (x y : ⨂[R] (i : ι), s i),
                                                      ZeroHom.toFun (↑src) (x + y) =
                                                        ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (x : ⨂[R] (i : ι), s i),
                                                  (liftAux φ) (r • x) = r • (liftAux φ) x) })
                                        φ₁ +
                                      (fun φ =>
                                          let src := liftAux φ;
                                          {
                                            toAddHom :=
                                              { toFun := src.toFun,
                                                map_add' :=
                                                  (_ :
                                                    ∀ (x y : ⨂[R] (i : ι), s i),
                                                      ZeroHom.toFun (↑src) (x + y) =
                                                        ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) },
                                            map_smul' :=
                                              (_ :
                                                ∀ (r : R) (x : ⨂[R] (i : ι), s i),
                                                  (liftAux φ) (r • x) = r • (liftAux φ) x) })
                                        φ₂) }
                          φ₂) }.toAddHom
          φ))
      x✝ =
    φ x✝

Next tactic:
simp [liftAux_tprod, LinearMap.compMultilinearMap]