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 :}
. 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 
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 dWith 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