Documentation

Mathlib.LinearAlgebra.Multilinear.Curry

Currying of multilinear maps #

We register isomorphisms corresponding to currying or uncurrying variables, transforming a multilinear function f on n+1 variables into a linear function taking values in multilinear functions in n variables, and into a multilinear function in n variables taking values in linear functions. These operations are called f.curryLeft and f.curryRight respectively (with inverses f.uncurryLeft and f.uncurryRight). These operations induce linear equivalences between spaces of multilinear functions in n+1 variables and spaces of linear functions into multilinear functions in n variables (resp. multilinear functions in n variables taking values in linear functions), called respectively multilinearCurryLeftEquiv and multilinearCurryRightEquiv.

Currying #

We associate to a multilinear map in n+1 variables (i.e., based on Fin n.succ) two curried functions, named f.curryLeft (which is a linear map on E 0 taking values in multilinear maps in n variables) and f.curryRight (which is a multilinear map in n variables taking values in linear maps on E 0). In both constructions, the variable that is singled out is 0, to take advantage of the operations cons and tail on Fin n. The inverse operations are called uncurryLeft and uncurryRight.

We also register linear equiv versions of these correspondences, in multilinearCurryLeftEquiv and multilinearCurryRightEquiv.

Left currying #

def LinearMap.uncurryLeft {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : M 0 →ₛₗ[σ] (Π (i : Fin n), M i.succ) →ₘₛₗ[σ] M₂) :
(Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂

Given a linear map f from M 0 to multilinear maps on n variables, construct the corresponding multilinear map on n+1 variables obtained by concatenating the variables, given by m ↦ f (m 0) (tail m)

Equations
Instances For
    @[simp]
    theorem LinearMap.uncurryLeft_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : M 0 →ₛₗ[σ] (Π (i : Fin n), M i.succ) →ₘₛₗ[σ] M₂) (m : (i : Fin n.succ) → M i) :
    f.uncurryLeft m = (f (m 0)) (Fin.tail m)
    def MultilinearMap.curryLeft {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
    M 0 →ₛₗ[σ] (Π (i : Fin n), M i.succ) →ₘₛₗ[σ] M₂

    Given a multilinear map f in n+1 variables, split the first variable to obtain a linear map into multilinear maps in n variables, given by x ↦ (m ↦ f (cons x m)).

    Equations
    Instances For
      @[simp]
      theorem MultilinearMap.curryLeft_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) (x : M 0) (m : (i : Fin n) → M i.succ) :
      (f.curryLeft x) m = f (Fin.cons x m)
      @[simp]
      theorem LinearMap.curry_uncurryLeft {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : M 0 →ₛₗ[σ] (Π (i : Fin n), M i.succ) →ₘₛₗ[σ] M₂) :
      @[simp]
      theorem MultilinearMap.uncurry_curryLeft {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
      def multilinearCurryLeftEquiv {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] :
      ((Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) ≃ₗ[S] M 0 →ₛₗ[σ] (Π (i : Fin n), M i.succ) →ₘₛₗ[σ] M₂

      The space of multilinear maps on Π (i : Fin (n+1)), M i is canonically isomorphic to the space of linear maps from M 0 to the space of multilinear maps on Π (i : Fin n), M i.succ, by separating the first variable. We register this isomorphism as a linear isomorphism in multilinearCurryLeftEquiv R M M₂.

      The direct and inverse maps are given by f.curryLeft and f.uncurryLeft. Use these unless you need the full framework of linear equivs.

      Equations
      Instances For
        @[simp]
        theorem multilinearCurryLeftEquiv_symm_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : M 0 →ₛₗ[σ] (Π (i : Fin n), M i.succ) →ₘₛₗ[σ] M₂) :
        @[simp]
        theorem multilinearCurryLeftEquiv_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :

        Right currying #

        def MultilinearMap.uncurryRight {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n), M i.castSucc) →ₘₛₗ[σ] M (Fin.last n) →ₛₗ[σ] M₂) :
        (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂

        Given a multilinear map f in n variables to the space of linear maps from M (last n) to M₂, construct the corresponding multilinear map on n+1 variables obtained by concatenating the variables, given by m ↦ f (init m) (m (last n))

        Equations
        Instances For
          @[simp]
          theorem MultilinearMap.uncurryRight_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n), M i.castSucc) →ₘₛₗ[σ] M (Fin.last n) →ₛₗ[σ] M₂) (m : (i : Fin n.succ) → M i) :
          f.uncurryRight m = (f (Fin.init m)) (m (Fin.last n))
          def MultilinearMap.curryRight {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
          (Π (i : Fin n), M i.castSucc) →ₘₛₗ[σ] M (Fin.last n) →ₛₗ[σ] M₂

          Given a multilinear map f in n+1 variables, split the last variable to obtain a multilinear map in n variables taking values in linear maps from M (last n) to M₂, given by m ↦ (x ↦ f (snoc m x)).

          Equations
          Instances For
            @[simp]
            theorem MultilinearMap.curryRight_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) (m : (i : Fin n) → M i.castSucc) (x : M (Fin.last n)) :
            (f.curryRight m) x = f (Fin.snoc m x)
            @[simp]
            theorem MultilinearMap.curry_uncurryRight {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n), M i.castSucc) →ₘₛₗ[σ] M (Fin.last n) →ₛₗ[σ] M₂) :
            @[simp]
            theorem MultilinearMap.uncurry_curryRight {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
            def multilinearCurryRightEquiv {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] :
            ((Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) ≃ₗ[S] (Π (i : Fin n), M i.castSucc) →ₘₛₗ[σ] M (Fin.last n) →ₛₗ[σ] M₂

            The space of multilinear maps on Π (i : Fin (n+1)), M i is canonically isomorphic to the space of linear maps from the space of multilinear maps on Π (i : Fin n), M (castSucc i) to the space of linear maps on M (last n), by separating the last variable. We register this isomorphism as a linear isomorphism in multilinearCurryRightEquiv R M M₂.

            The direct and inverse maps are given by f.curryRight and f.uncurryRight. Use these unless you need the full framework of linear equivs.

            Equations
            Instances For
              def LinearMap.uncurryMid {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) (f : M p →ₛₗ[σ] (Π (i : Fin n), M (p.succAbove i)) →ₘₛₗ[σ] M₂) :
              (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂

              Given a linear map from M p to the space of multilinear maps in n variables M 0, ..., M n with M p removed, returns a multilinear map in all n + 1 variables.

              Equations
              Instances For
                @[simp]
                theorem LinearMap.uncurryMid_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) (f : M p →ₛₗ[σ] (Π (i : Fin n), M (p.succAbove i)) →ₘₛₗ[σ] M₂) (m : (i : Fin n.succ) → M i) :
                (uncurryMid p f) m = (f (m p)) (p.removeNth m)
                def MultilinearMap.curryMid {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
                M p →ₛₗ[σ] (Π (i : Fin n), M (p.succAbove i)) →ₘₛₗ[σ] M₂

                Interpret a multilinear map in n + 1 variables as a linear map in pth variable with values in the multilinear maps in the other variables.

                Equations
                Instances For
                  @[simp]
                  theorem MultilinearMap.curryMid_apply_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) (x : M p) (m : (i : Fin n) → M (p.succAbove i)) :
                  ((curryMid p f) x) m = f (p.insertNth x m)
                  @[simp]
                  theorem LinearMap.curryMid_uncurryMid {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (i : Fin (n + 1)) (f : M i →ₛₗ[σ] (Π (j : Fin n), M (i.succAbove j)) →ₘₛₗ[σ] M₂) :
                  @[simp]
                  theorem MultilinearMap.uncurryMid_curryMid {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (i : Fin (n + 1)) (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
                  def MultilinearMap.curryMidLinearEquiv {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) :
                  ((Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) ≃ₗ[S] M p →ₛₗ[σ] (Π (i : Fin n), M (p.succAbove i)) →ₘₛₗ[σ] M₂

                  MultilinearMap.curryMid as a linear equivalence.

                  Equations
                  Instances For
                    @[simp]
                    theorem MultilinearMap.curryMidLinearEquiv_symm_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) (f : M p →ₛₗ[σ] (Π (i : Fin n), M (p.succAbove i)) →ₘₛₗ[σ] M₂) :
                    @[simp]
                    theorem MultilinearMap.curryMidLinearEquiv_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [(i : Fin n.succ) → AddCommMonoid (M i)] [AddCommMonoid M₂] [(i : Fin n.succ) → Module R (M i)] [Module S M₂] (p : Fin (n + 1)) (f : (Π (i : Fin n.succ), M i) →ₘₛₗ[σ] M₂) :
                    (curryMidLinearEquiv σ M M₂ p) f = curryMid p f
                    def MultilinearMap.currySum {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (f : (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) :
                    (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂

                    Given a family of modules N : (ι ⊕ ι') → Type*, a multilinear map on (fun _ : ι ⊕ ι' => M') induces a multilinear map on (fun (i : ι) ↦ N (.inl i)) taking values in the space of linear maps on (fun (i : ι') ↦ N (.inr i)).

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      @[simp]
                      theorem MultilinearMap.currySum_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (f : (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) (u : (i : ι) → N (Sum.inl i)) (v : (i : ι') → N (Sum.inr i)) :
                      (f.currySum u) v = f fun (t : ι ⊕ ι') => Sum.rec u v t
                      @[simp]
                      theorem MultilinearMap.currySum_apply' {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : Type u_2} [AddCommMonoid N] [Module R N] (f : (ι ⊕ ι' → N) →ₘₛₗ[σ] M₂) (u : ι → N) (v : ι' → N) :
                      (f.currySum u) v = f (Sum.elim u v)
                      @[simp]
                      theorem MultilinearMap.currySum_add {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (f₁ f₂ : (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) :
                      (f₁ + f₂).currySum = f₁.currySum + f₂.currySum
                      @[simp]
                      theorem MultilinearMap.currySum_smul {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (r : S) (f : (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) :
                      def MultilinearMap.uncurrySum {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (g : (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂) :
                      (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂

                      Given a family of modules N : (ι ⊕ ι') → Type*, a multilinear map on (fun (i : ι) ↦ N (.inl i)) taking values in the space of linear maps on (fun (i : ι') ↦ N (.inr i)) induces a multilinear map on (fun _ : ι ⊕ ι' => M') induces.

                      Equations
                      • g.uncurrySum = { toFun := fun (u : (i : ι ⊕ ι') → N i) => (g fun (i : ι) => u (Sum.inl i)) fun (i' : ι') => u (Sum.inr i'), map_update_add' := ⋯, map_update_smul' := ⋯ }
                      Instances For
                        @[simp]
                        theorem MultilinearMap.uncurrySum_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (g : (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂) (u : (i : ι ⊕ ι') → N i) :
                        g.uncurrySum u = (g fun (i : ι) => u (Sum.inl i)) fun (i' : ι') => u (Sum.inr i')
                        @[simp]
                        theorem MultilinearMap.uncurrySum_add {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (g₁ g₂ : (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂) :
                        (g₁ + g₂).uncurrySum = g₁.uncurrySum + g₂.uncurrySum
                        theorem MultilinearMap.uncurrySum_smul {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (r : S) (g : (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂) :
                        @[simp]
                        theorem MultilinearMap.uncurrySum_currySum {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (f : (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) :
                        @[simp]
                        theorem MultilinearMap.currySum_uncurrySum {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (g : (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂) :
                        def MultilinearMap.currySumEquiv {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] :
                        ((Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) ≃ₗ[S] (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂

                        Multilinear maps on N : (ι ⊕ ι') → Type* identify to multilinear maps from (fun (i : ι) ↦ N (.inl i)) taking values in the space of linear maps on (fun (i : ι') ↦ N (.inr i)).

                        Equations
                        Instances For
                          @[simp]
                          theorem MultilinearMap.currySumEquiv_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (f : (Π (i : ι ⊕ ι'), N i) →ₘₛₗ[σ] M₂) :
                          @[simp]
                          theorem MultilinearMap.currySumEquiv_symm_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] (g : (Π (i : ι), N (Sum.inl i)) →ₘₛₗ[σ] (Π (i : ι'), N (Sum.inr i)) →ₘₛₗ[σ] M₂) :
                          @[simp]
                          theorem MultilinearMap.coe_currySumEquiv {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] :
                          @[simp]
                          theorem MultilinearMap.coe_currySumEquiv_symm {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [AddCommMonoid M₂] [Module S M₂] {N : ι ⊕ ι' → Type u_1} [(i : ι ⊕ ι') → AddCommMonoid (N i)] [(i : ι ⊕ ι') → Module R (N i)] :
                          def MultilinearMap.curryFinFinset {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] (σ : R →+* S) (M₂ : Type v₂) (M' : Type v') [AddCommMonoid M'] [AddCommMonoid M₂] [Module R M'] [Module S M₂] {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) :
                          ((Fin n → M') →ₘₛₗ[σ] M₂) ≃ₗ[S] (Fin k → M') →ₘₛₗ[σ] (Fin l → M') →ₘₛₗ[σ] M₂

                          If s : Finset (Fin n) is a finite set of cardinality k and its complement has cardinality l, then the space of multilinear maps on fun i : Fin n => M' is isomorphic to the space of multilinear maps on fun i : Fin k => M' taking values in the space of multilinear maps on fun i : Fin l => M'.

                          Equations
                          Instances For
                            @[simp]
                            theorem MultilinearMap.curryFinFinset_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {M₂ : Type v₂} {M' : Type v'} [AddCommMonoid M'] [AddCommMonoid M₂] [Module R M'] [Module S M₂] {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) (f : (Fin n → M') →ₘₛₗ[σ] M₂) (mk : Fin k → M') (ml : Fin l → M') :
                            (((curryFinFinset σ M₂ M' hk hl) f) mk) ml = f fun (i : Fin n) => Sum.elim mk ml ((finSumEquivOfFinset hk hl).symm i)
                            @[simp]
                            theorem MultilinearMap.curryFinFinset_symm_apply {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {M₂ : Type v₂} {M' : Type v'} [AddCommMonoid M'] [AddCommMonoid M₂] [Module R M'] [Module S M₂] {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) (f : (Fin k → M') →ₘₛₗ[σ] (Fin l → M') →ₘₛₗ[σ] M₂) (m : Fin n → M') :
                            ((curryFinFinset σ M₂ M' hk hl).symm f) m = (f fun (i : Fin k) => m ((finSumEquivOfFinset hk hl) (Sum.inl i))) fun (i : Fin l) => m ((finSumEquivOfFinset hk hl) (Sum.inr i))
                            theorem MultilinearMap.curryFinFinset_symm_apply_piecewise_const {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {M₂ : Type v₂} {M' : Type v'} [AddCommMonoid M'] [AddCommMonoid M₂] [Module R M'] [Module S M₂] {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) (f : (Fin k → M') →ₘₛₗ[σ] (Fin l → M') →ₘₛₗ[σ] M₂) (x y : M') :
                            ((curryFinFinset σ M₂ M' hk hl).symm f) (s.piecewise (fun (x_1 : Fin n) => x) fun (x : Fin n) => y) = (f fun (x_1 : Fin k) => x) fun (x : Fin l) => y
                            @[simp]
                            theorem MultilinearMap.curryFinFinset_symm_apply_const {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {M₂ : Type v₂} {M' : Type v'} [AddCommMonoid M'] [AddCommMonoid M₂] [Module R M'] [Module S M₂] {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) (f : (Fin k → M') →ₘₛₗ[σ] (Fin l → M') →ₘₛₗ[σ] M₂) (x : M') :
                            (((curryFinFinset σ M₂ M' hk hl).symm f) fun (x_1 : Fin n) => x) = (f fun (x_1 : Fin k) => x) fun (x_1 : Fin l) => x
                            theorem MultilinearMap.curryFinFinset_apply_const {R : Type uR} {S : Type uS} [Semiring R] [CommSemiring S] {σ : R →+* S} {M₂ : Type v₂} {M' : Type v'} [AddCommMonoid M'] [AddCommMonoid M₂] [Module R M'] [Module S M₂] {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k) (hl : sᶜ.card = l) (f : (Fin n → M') →ₘₛₗ[σ] M₂) (x y : M') :
                            ((((curryFinFinset σ M₂ M' hk hl) f) fun (x_1 : Fin k) => x) fun (x : Fin l) => y) = f (s.piecewise (fun (x_1 : Fin n) => x) fun (x : Fin n) => y)