9.2. Replace indices

A second, commonly required operation is the change of indices. In principle, the user should never need to replace indices directly in an expression. But sometimes it is needed, either because two expressions with different free indices must be compared, or to avoid problems with the dummy indices. This subsection introduces the basic function ReplaceIndex, and five more functions based on it.
Replacing indices is a basic critical operation: done without care would inmediately lead to wrong results. Whenever possible, we recommend the use of delta contractions to change indices, which is a safer and mathematically clearer operation.

Above all, avoid the temptation of changing indices using normal rules, unless you are sure that index-collisions will not appear.

Let us go back to our expression:

In[892]:=

Out[892]=

For similar reasons, ReplaceIndex has attribute HoldFirst, and hence we need Evaluate. We can replace a single index:

In[893]:=

Out[893]=

Note that the paired index -a has not been replaced. We need separate rules for that (this gives greater flexibility):

In[894]:=

Out[894]=

We can change the character of an index, or even the type:

In[895]:=

Out[895]=

If the rules do not apply, nothing happens:

In[896]:=

Out[896]=

Pattern indices can be changed, but this should never be required:

In[897]:=

Out[897]=

The replacement is performed with great care. In the following list T is a tensor, but X is not a tensor:

In[898]:=

Out[898]=

As I said, the user should try to refrain from using ReplaceIndex. If a free index must be changed, use contractions with delta tensors: if we want to change from T[a] to T[b] we can do this:

In[899]:=

Out[899]=

In some cases we need to change the dummy indices of an expression. For example when we want to multiply a previous expression by itself. ReplaceDummies is the function which calls ReplaceIndex to manipulate all possible cases with dummies. A particular case, always required in the canonicalization process, is implemented in SameDummies.

Suppose now this scalar expression:

In[900]:=

Out[900]=

This is incorrect:

In[901]:=

Out[901]=

The following is correct. ReplaceDummies changes the dummy by the given indices

In[902]:=

Out[902]=

If not enough indices (or no index at all) are given, the dummies are replaced by unique  dollar-indices:

In[903]:=

Out[903]=

In[904]:=

Out[904]=

A particular case of dummy manipulation is the minimization of the number of dummies in a sum of terms. This is achieved using SameDummies, which is simply a combined call to FindDummyIndices and ReplaceDummies.

In[905]:=

Out[905]=

In parallel, sometimes we need to change the free indices of an expression. This happens for example when we need to compare the results of several independent computations. If we do not know the index translation table which brings one expression to the other, then we need to search among all permutations, what could take quite some time...

This changes the free indices a,c to b,e. The index b was a dummy in the original expression, and hence it must be replaced (by a unique dollar-dummy) before actually changing the free indices:

In[906]:=

Out[906]=

It is not obvious to see whether these two expressions are the same or not under a renaming of free indices:

In[907]:=

Out[907]=

Out[908]=

The function EqualExpressionsQ gives True if one is simply a constant times the other, and False otherwise:

In[909]:=

Out[909]=

In[910]:=

Out[910]=

Finally, we introduce the operation of index splitting. The key idea is the concept of a splitrule of the form   a -> IndexList[ a1, a2, ... ].  The function SplitIndex is rather efficient because it uses ReplaceIndex only once, replacing the index by a temporary variable, which is later used to do all other replacements with ReplaceAll, which is much faster.

We can construct a list of replacements as follows:

In[911]:=

Out[911]=

or an array:

In[912]:=

Out[912]=

In[913]:=

Out[913]=

There is also a combined notation for multiple expansions over the same range. Again, this is performed through a single call to ReplaceIndex.

In[914]:=

Out[914]=

ReplaceIndex            Replace an index by another index in an expression
ReplaceDummies            Replace dummy indices by new dummy indices
SameDummies                Minimize number of different dummy indices among several terms of a sum
ChangeFreeIndices        Change free indices of an expression
EqualExpressionsQ        Check whether two expressions are proportional to each other apart from a renaming of free indices
SplitIndex                Return a list of expressions where an index has been replace by different possibilities in a list
TraceDummy                Return a sum expressions where a dummy pair has been replace by different possibilities in a list

Index replacements.

Created by Mathematica  (May 16, 2008)