# Symmetrize

### Description

• Symmetrize[indices] makes expression symmetries same to the symmetries of indices
• Symmetrize[indices] makes expression symmetric only with respect to specified indices
• Symmetrize[indices] will also multiply the result on the symmetric factor

### Examples

Symmetrize indices a and b in expression:

def indices = '_ab'.si
indices.symmetries.setSymmetric()
println Symmetrize[indices] >> 'T_ab'.t

   > T_{ab}/2 + T_{ba}/2


Antisymmetrize indices a and b in expression:

def indices = '_ab'.si
indices.symmetries.setAntiSymmetric()
println Symmetrize[indices] >> 'T_ab'.t

   > T_{ab}/2 - T_{ba}/2


Symmetrize a complicated expression

def indices = '_ab'.si
indices.symmetries.setAntiSymmetric()
println Symmetrize[indices] >> 'T_ac*F^c_b - F_bc*T^c_a'.t

   > T_{ac}*F^{c}_{b}/2-T_{bc}*F^{c}_{a}/2-T^{c}_{a}*F_{bc}/2+T^{c}_{b}*F_{ac}/2


Symmetrize part of indices

def indices = '_abc'.si
indices.symmetries.setSymmetric()
println Symmetrize[indices] >> 'T_abcde'.t

   > T_{bcade}/6+T_{cabde}/6+T_{cbade}/6+T_{abcde}/6+T_{acbde}/6+T_{bacde}/6


Make symmetries equal to specified permutation group

def indices = '_abcd'.si
println Symmetrize[indices] >> '8*R_abcd'.t

   > -R_{abdc}-R_{dcab}-R_{cdba}+R_{badc}+R_{dcba}+R_{cdab}+R_{abcd}-R_{bacd}


Symmetrize will have no effect if tensor already has such symmetries:

setSymmetric 'F_abcd'
def indices = '_bcd'.si
println Symmetrize[indices] >> 'F_abcd'.t

   > F_{abdc}


### Details

Symmetries are defined relatively to the specified indices:

def indices = '_abc'.si
println Symmetrize[indices] >> 'F_abc'.t

   > (1/2)*F_{bac}+(1/2)*F_{abc}

indices = '_cab'.si
println Symmetrize[indices] >> 'F_abc'.t

   > (1/2)*F_{abc}+(1/2)*F_{cba}


Implement transformation that makes expression fully symmetric with respect to all indices:

def Symmetric = { expr ->
def indices = expr.indices.si //convert indices of expr to simple indices
indices.symmetries.setSymmetric()
return Symmetrize[indices] >> expr
} as Transformation

println Symmetric >> '6*f_abc'.t

   > f_{cab}+f_{acb}+f_{abc}+f_{cba}+f_{bac}+f_{bca}


Same for fully antisymmetric transformation:

def AntiSymmetric = { expr ->
def indices = expr.indices.si //convert indices of expr to simple indices
indices.symmetries.setAntiSymmetric()
return Symmetrize[indices] >> expr
} as Transformation

println AntiSymmetric >> '6*f_abc'.t

   > f_{bca}+f_{cab}-f_{cba}-f_{bac}+f_{abc}-f_{acb}