Wolfram Language & System Documentation Center

TensorExpand

TensorExpand[texpr]

expands out tensor-related products in the symbolic tensor expression texpr.

Details and Options

TensorExpand expands sums and products by scalars in tensorial arguments.
Expressions involving Dot and Cross are expanded by converting products of pairs of Cross subexpressions into linear combinations of Dot products.
Symbolic arguments of Cross are assumed to represent vectors of adequate dimensionality.
Symbolic arguments of MatrixPower and Inverse are assumed to represent invertible square matrices.

Examples

open all close all

Basic Examples (2)

Tensor products of linear combinations are not expanded automatically:

Wolfram Language code: (v1 + v2)(w1 - 2w2)

Expand the product:

Wolfram Language code: %//TensorExpand

Expand a scalar product of two cross products:

Wolfram Language code: (a⨯b).(c⨯d)//TensorExpand

Scope (3)

Act on expressions containing all kinds of products:

Wolfram Language code: (2a + b)c//TensorExpand

Wolfram Language code: (2a + b)c//TensorExpand

Wolfram Language code: (2a + b).c//TensorExpand

Wolfram Language code: (2a + b)c//TensorExpand

Wolfram Language code: (2a + b)⨯c//TensorExpand

Act on expressions containing both symbolic and explicit objects:

Wolfram Language code: (2a + b){x, y, z}//TensorExpand

For some operations, additional information needs to be supplied. The Dot product is not commutative in general:

Wolfram Language code: a.b - b.a//TensorExpand

However, if the objects are declared as vectors, then it is commutative:

Wolfram Language code: Assuming[(a | b)∈Vectors[dim], %//TensorExpand]

Options (1)

Assumptions (1)

This expression cannot be canonicalized because the rank of a is unknown:

Wolfram Language code: TensorExpand[(b⨯c).a]

Assume that a is a vector:

Wolfram Language code: TensorExpand[(b⨯c).a, Assumptions -> a∈Vectors[3]]

Applications (6)

Linearity expansions:

Wolfram Language code: (2v - w).w//TensorExpand

Wolfram Language code: (7v - 3w)⨯(w + v)//TensorExpand

Vector identities in dimension 3:

Wolfram Language code: (v⨯w).v//TensorExpand

Wolfram Language code: w⨯v//TensorExpand

Wolfram Language code: a⨯(b⨯c)//TensorExpand

Wolfram Language code: (a⨯b)⨯c == -c⨯(a⨯b) == -a(b.c) + b(a.c)//TensorExpand

Wolfram Language code: (a⨯b).(c⨯d)//TensorExpand

Wolfram Language code: (a⨯b).(c⨯d) == (a⨯c).(b⨯d) - (b⨯c).(a⨯d)//TensorExpand

Wolfram Language code: a⨯(b⨯(c⨯d)) == b a.(c⨯d) - (a.b)c⨯d//TensorExpand

Wolfram Language code: a (b⨯c).d - b(a⨯c).d + c(a⨯b).d - d(a⨯b).c == 0//TensorExpand

Wolfram Language code: ((a⨯b).c) ^ 4//TensorExpand

Vector identities in dimension 4:

Wolfram Language code: a⨯b⨯c == b⨯c⨯a//TensorExpand

Wolfram Language code: (a⨯b⨯c).(d⨯e⨯f)//TensorExpand

Wolfram Language code: (a⨯b⨯c)⨯(a⨯b⨯d)⨯(a⨯b⨯e) == 0//TensorExpand

Combination of transpositions:

Wolfram Language code: Transpose[Transpose[A, {2, 3, 1}], {2, 1, 3}]//TensorExpand

Wolfram Language code: ConjugateTranspose[Transpose[A, {2, 3, 1}]]//TensorExpand

Powers of matrices. Matrices are assumed invertible:

Wolfram Language code: MatrixPower[M, 4].M.M.Inverse[M]//TensorExpand

Wolfram Language code: MatrixPower[Transpose[Inverse[Transpose[M]]], 4]//TensorExpand

Declare a, b, c to be three-dimensional vectors:

Wolfram Language code: $Assumptions = (a | b | c)∈Vectors[3]

Then these formulas effectively invert the matrix {a,b,c}:

Wolfram Language code:

ap = (b⨯c/a.b⨯c);
bp = (c⨯a/a.b⨯c);
cp = (a⨯b/a.b⨯c);

Wolfram Language code: Outer[Dot, {a, b, c}, {ap, bp, cp}]//TensorExpand

Possible Issues (2)

Expansion of pairs of vector products requires consistent dimensions:

Wolfram Language code: (a⨯b⨯c)⨯(d⨯e⨯f)//TensorExpand

With symbolic expressions, the result may be given as 0, representing a 0 vector or tensor:

Wolfram Language code: a⨯a//TensorExpand

Compare with:

Wolfram Language code: {x, y, z}⨯{x, y, z}

Neat Examples (1)

Declare a family of vectors:

Wolfram Language code: TensorRank[Subscript[v, n_]] ^= 1;

For each integer n, there is a tree expression involving n Cross operations for n+1 vectors v₀,…,v_n:

Wolfram Language code:

TreeCross[0] := Subscript[v, 0];
TreeCross[n_] := TreeCross[n - 1] /. With[{m = BitClear[n, Floor@Log[2, n]]}, Subscript[v, m] -> Cross[Subscript[v, m], Subscript[v, n]]]

Wolfram Language code: TreeCross[7]

Wolfram Language code: TreeForm[%, 3]

Now systematically convert all possible combinations of cross products into dot products and one cross product:

Wolfram Language code: Do[Print[TreeCross[n] == TensorExpand[TreeCross[n]]], {n, 0, 8}]