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
indices.symmetries.add(-[1, 0].p)
indices.symmetries.add([2, 3, 0, 1].p)
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
indices.symmetries.add([1, 0, 2].p)
println Symmetrize[indices] >> 'F_abcd'.t
   > F_{abdc}


Details


Symmetries are defined relatively to the specified indices:

def indices = '_abc'.si
indices.symmetries.add([1, 0, 2].p)
println Symmetrize[indices] >> 'F_abc'.t
   > (1/2)*F_{bac}+(1/2)*F_{abc}
indices = '_cab'.si
indices.symmetries.add([1, 0, 2].p)
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}


See also