# Tensors

*Tensors* are mathematical objects that give generalizations of vectors and matrices. In *Mathematica*, a tensor is represented as a set of lists, nested to a certain number of levels. The nesting level is the *rank* of the tensor.

Interpretations of nested lists.

A tensor of rank k is essentially a k-dimensional table of values. To be a true rank k tensor, it must be possible to arrange the elements in the table in a k-dimensional cuboidal array. There can be no holes or protrusions in the cuboid.

The *indices* that specify a particular element in the tensor correspond to the coordinates in the cuboid. The *dimensions* of the tensor correspond to the side lengths of the cuboid.

One simple way that a rank k tensor can arise is in giving a table of values for a function of k variables. In physics, the tensors that occur typically have indices which run over the possible directions in space or spacetime. Notice, however, that there is no built-in notion of covariant and contravariant tensor indices in *Mathematica*: you have to set these up explicitly using metric tensors.

Table[f,{i_{1},n_{1}},{i_{2},n_{2}},...,{i_{k},n_{k}}] | |

create an ××...× tensor whose elements are the values of f | |

Array[a,{n_{1},n_{2},...,n_{k}}] | create an ××...× tensor with elements given by applying a to each set of indices |

ArrayQ[t,n] | test whether t is a tensor of rank n |

Dimensions[t] | give a list of the dimensions of a tensor |

ArrayDepth[t] | find the rank of a tensor |

MatrixForm[t] | print with the elements of t arranged in a two-dimensional array |

Functions for creating and testing the structure of tensors.

In[1]:= |

Out[1]= |

In[2]:= |

Out[2]= |

In[3]:= |

Out[3]//MatrixForm= | |

In[4]:= |

Out[4]= |

In[5]:= |

Out[5]= |

In[6]:= |

Out[6]= |

The rank of a tensor is equal to the number of indices needed to specify each element. You can pick out subtensors by using a smaller number of indices.

Transpose[t] | transpose the first two indices in a tensor |

Transpose[t,{p_{1},p_{2},...}] | transpose the indices in a tensor so that the k becomes the |

Tr[t,f] | form the generalized trace of the tensor t |

Outer[f,t_{1},t_{2}] | form the generalized outer product of the tensors and with "multiplication operator" f |

t_{1}.t_{2} | form the dot product of and (last index of contracted with first index of ) |

Inner[f,t_{1},t_{2},g] | form the generalized inner product, with "multiplication operator" f and "addition operator" g |

Tensor manipulation operations.

You can think of a rank k tensor as having k "slots" into which you insert indices. Applying Transpose is effectively a way of reordering these slots. If you think of the elements of a tensor as forming a k-dimensional cuboid, you can view Transpose as effectively rotating (and possibly reflecting) the cuboid.

In the most general case, Transpose allows you to specify an arbitrary reordering to apply to the indices of a tensor. The function Transpose[T, {p_{1}, p_{2}, ..., p_{k}}] gives you a new tensor such that the value of is given by .

If you originally had an ××...× tensor, then by applying Transpose, you will get an ××...× tensor.

In[7]:= |

Out[7]= |

In[8]:= |

Out[8]= |

In[9]:= |

Out[9]= |

In[10]:= |

Out[10]= |

In[11]:= |

Out[11]= |

In[12]:= |

Out[12]= |

If you have a tensor that contains lists of the same length at different levels, then you can use Transpose to effectively collapse different levels.

In[13]:= |

Out[13]= |

In[14]:= |

Out[14]= |

You can also use Tr to extract diagonal elements of a tensor.

In[15]:= |

Out[15]= |

In[16]:= |

Out[16]= |

In[17]:= |

Out[17]= |

Outer products, and their generalizations, are a way of building higher-rank tensors from lower-rank ones. Outer products are also sometimes known as direct, tensor, or Kronecker products.

From a structural point of view, the tensor you get from Outer[f, t, u] has a copy of the structure of u inserted at the "position" of each element in t. The elements in the resulting structure are obtained by combining elements of t and u using the function f.

In[18]:= |

Out[18]= |

In[19]:= |

Out[19]= |

In[20]:= |

Out[20]= |

In[21]:= |

Out[21]= |

If you take the generalized outer product of an ××...× tensor and an ××...× tensor, you get an ×...×××...× tensor. If the original tensors have ranks r and s, your result will be a rank tensor.

In terms of indices, the result of applying Outer to two tensors and is the tensor with elements .

In doing standard tensor calculations, the most common function f to use in Outer is Times, corresponding to the standard outer product.

Particularly in doing combinatorial calculations, however, it is often convenient to take f to be List. Using Outer, you can then get combinations of all possible elements in one tensor, with all possible elements in the other.

In constructing Outer[f, t, u] you effectively insert a copy of u at every point in t. To form Inner[f, t, u], you effectively combine and collapse the last dimension of t and the first dimension of u. The idea is to take an ××...× tensor and an ××...× tensor, with , and get an ××...×××...× tensor as the result.

The simplest examples are with vectors. If you apply Inner to two vectors of equal length, you get a scalar. Inner[f, v_{1}, v_{2}, g] gives a generalization of the usual scalar product, with f playing the role of multiplication, and g playing the role of addition.

In[22]:= |

Out[22]= |

In[23]:= |

Out[23]= |

In[24]:= |

Out[24]= |

In[25]:= |

Out[25]= |

In[26]:= |

Out[26]= |

In[27]:= |

Out[27]= |

You can think of Inner as performing a "contraction" of the last index of one tensor with the first index of another. If you want to perform contractions across other pairs of indices, you can do so by first transposing the appropriate indices into the first or last position, then applying Inner, and then transposing the result back.

In many applications of tensors, you need to insert signs to implement antisymmetry. The function Signature[{i_{1}, i_{2}, ...}], which gives the signature of a permutation, is often useful for this purpose.

Outer[f,t_{1},t_{2},...] | form a generalized outer product by combining the lowest-level elements of |

Outer[f,t_{1},t_{2},...,n] | treat only sublists at level n as separate elements |

Outer[f,t_{1},t_{2},...,n_{1},n_{2},...] | treat only sublists at level in as separate elements |

Inner[f,t_{1},t_{2},g] | form a generalized inner product using the lowest-level elements of |

Inner[f,t_{1},t_{2},g,n] | contract index n of the first tensor with the first index of the second tensor |

Treating only certain sublists in tensors as separate elements.

In[28]:= |

Out[28]= |

In[29]:= |

Out[29]= |

ArrayFlatten[t,r] | create a flat rank r tensor from a rank r tensor of rank r tensors |

ArrayFlatten[t] | flatten a matrix of matrices (equivalent to ArrayFlatten[t, 2]) |

In[30]:= |

Out[30]//TableForm= | |

In[31]:= |

Out[31]//TableForm= | |