Symmetrization



next up previous contents index
Next: The Robertson-Walker Metric Up: The Index Previous: Shift Operations

Symmetrization

  It is frequently the case in General Relativity that a new object of interest is constructed from some other object (or objects) by permuting its indices and adding the resultant objects together. These symmetrization operations can be indicated in the index of an object by enclosing the indices to be permuted in symmetrization           operators: :[ and :]; or anti-symmetrization operators: :{ and :}gif. The anti-symmetrization operators cause a sign change when swapping adjacent index elements, whereas the symmetrization operators do not. Using the objects created on page gif we have, for example,

 
#: q[:[a,b:]];

    a b    b a
  (q    + q   )/2

#: w[:[a,b:]];

    a b
   w

#: w[:{a,b:}];

   0

#: 3*R[a,b,:{c,d,||e:}];

  R            - R            + R
   a b c d ||e    a b c e ||d    a b d e ||c

Each time the index is permuted according to the indicated symmetrization, the intrinsic symmetries of the object are applied to put the index into a canonical form. Thus it may be the case that significant simplification can occur before the actual evaluation of the expression is begun. The last expression above is an example of how the Bianchi identities can be calculated, assuming R had been given values.

Bach brackets can be used to isolate some indices from the     symmetrization, and these are indicated by writing a :& symbol in the index as if it were a separate index element, i.e. it has commas on both sides, unlike the @ and | operators.

 
#: R[:[a,:&,b,c,:&,d]:];

 (R        + R       )/2
   a b c d    a c b d
With REDTEN version v4.00 the previous restriction that a symmetrization involve no more than 4 indices was removed (although it will take much longer to evaluate larger operations, as the number of terms grows with the factorial of the number of indices). Also new in this version is the function symz(), which can be used to apply a symmetrization across the product of several indexed objects. The system still cannot apply intermixed symmetrizations separately to covariant and contravariant indices.

To use symz() simply give an indexed expression as the single argument to the function. At least one pair of matching symmetrization operators should appear (it's a no-op otherwise), but they are no longer restricted to appearing in the same index: the opening op can appear in one index, and the closing op in another. Obviously, the opening op should appear before the closing op (the usual REDUCE reordering of expressions is suppressed until the symmetrization has been evaluated). Writing a distributed symmetrization that is not the argument to symz() will result in an error. For example,

 
#: symz(q[a,:[b]*w[c:],d]);

   a b  c d    a c  b d
  q    w    + q    w
 -----------------------
            2
All the operators and rules that apply to a symmetrization in a single index apply here across the combined index of the terms in the expression.

If the switch symzexp is off, the symmetrization operations are not evaluated until the expression is involved in an indexed assignment. In this case, symz() returns unevaluated:

 
#: off symzexp;

#: symz(q[a,:[b]*w[c:],d]);

  a [b  c] d
 q     w


next up previous contents index
Next: The Robertson-Walker Metric Up: The Index Previous: Shift Operations



John Harper
Wed Nov 16 13:34:23 EST 1994