X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fclifford.cpp;h=547285d0f3355f693bd0f2aafb5f9d33decca998;hp=11f84d0c256e281ad915b3a5b09a7f388e2071fe;hb=68fdf425abf14d016d5f95ee7b9d06a19a3c5926;hpb=cfea748404dec5fb2f2e3310d36eeb6640f13824 diff --git a/ginac/clifford.cpp b/ginac/clifford.cpp index 11f84d0c..547285d0 100644 --- a/ginac/clifford.cpp +++ b/ginac/clifford.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's clifford algebra (Dirac gamma) objects. */ /* - * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,6 +20,9 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include +#include + #include "clifford.h" #include "ex.h" #include "idx.h" @@ -29,22 +32,23 @@ #include "symmetry.h" #include "lst.h" #include "relational.h" +#include "operators.h" #include "mul.h" #include "print.h" #include "archive.h" #include "utils.h" -#include - namespace GiNaC { GINAC_IMPLEMENT_REGISTERED_CLASS(clifford, indexed) GINAC_IMPLEMENT_REGISTERED_CLASS(diracone, tensor) GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma, tensor) GINAC_IMPLEMENT_REGISTERED_CLASS(diracgamma5, tensor) +GINAC_IMPLEMENT_REGISTERED_CLASS(diracgammaL, tensor) +GINAC_IMPLEMENT_REGISTERED_CLASS(diracgammaR, tensor) ////////// -// default ctor, dtor, copy ctor, assignment operator and helpers +// default constructors ////////// clifford::clifford() : representation_label(0) @@ -52,16 +56,11 @@ clifford::clifford() : representation_label(0) tinfo_key = TINFO_clifford; } -void clifford::copy(const clifford & other) -{ - inherited::copy(other); - representation_label = other.representation_label; -} - -DEFAULT_DESTROY(clifford) -DEFAULT_CTORS(diracone) -DEFAULT_CTORS(diracgamma) -DEFAULT_CTORS(diracgamma5) +DEFAULT_CTOR(diracone) +DEFAULT_CTOR(diracgamma) +DEFAULT_CTOR(diracgamma5) +DEFAULT_CTOR(diracgammaL) +DEFAULT_CTOR(diracgammaR) ////////// // other constructors @@ -98,7 +97,7 @@ clifford::clifford(unsigned char rl, exvector * vp) : inherited(sy_none(), vp), // archiving ////////// -clifford::clifford(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +clifford::clifford(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst) { unsigned rl; n.find_unsigned("label", rl); @@ -115,6 +114,8 @@ DEFAULT_UNARCHIVE(clifford) DEFAULT_ARCHIVING(diracone) DEFAULT_ARCHIVING(diracgamma) DEFAULT_ARCHIVING(diracgamma5) +DEFAULT_ARCHIVING(diracgammaL) +DEFAULT_ARCHIVING(diracgammaR) ////////// // functions overriding virtual functions from base classes @@ -143,7 +144,9 @@ bool clifford::match_same_type(const basic & other) const void clifford::print(const print_context & c, unsigned level) const { - if (!is_a(seq[0]) && !is_a(seq[0]) && !is_a(seq[0])) { + if (!is_a(seq[0]) && !is_a(seq[0]) && + !is_a(seq[0]) && !is_a(seq[0]) && + !is_a(seq[0])) { // dirac_slash() object is printed differently if (is_a(c)) @@ -164,10 +167,14 @@ void clifford::print(const print_context & c, unsigned level) const DEFAULT_COMPARE(diracone) DEFAULT_COMPARE(diracgamma) DEFAULT_COMPARE(diracgamma5) +DEFAULT_COMPARE(diracgammaL) +DEFAULT_COMPARE(diracgammaR) DEFAULT_PRINT_LATEX(diracone, "ONE", "\\mathbb{1}") DEFAULT_PRINT_LATEX(diracgamma, "gamma", "\\gamma") DEFAULT_PRINT_LATEX(diracgamma5, "gamma5", "{\\gamma^5}") +DEFAULT_PRINT_LATEX(diracgammaL, "gammaL", "{\\gamma_L}") +DEFAULT_PRINT_LATEX(diracgammaR, "gammaR", "{\\gamma_R}") /** This function decomposes gamma~mu -> (1, mu) and a\ -> (a.ix, ix) */ static void base_and_index(const ex & c, ex & b, ex & i) @@ -178,6 +185,9 @@ static void base_and_index(const ex & c, ex & b, ex & i) if (is_a(c.op(0))) { // proper dirac gamma object i = c.op(1); b = _ex1; + } else if (is_a(c.op(0)) || is_a(c.op(0)) || is_a(c.op(0))) { // gamma5/L/R + i = _ex0; + b = _ex1; } else { // slash object, generate new dummy index varidx ix((new symbol)->setflag(status_flags::dynallocated), ex_to(c.op(1)).get_dim()); b = indexed(c.op(0), ix.toggle_variance()); @@ -193,9 +203,15 @@ bool diracgamma::contract_with(exvector::iterator self, exvector::iterator other GINAC_ASSERT(is_a(self->op(0))); unsigned char rl = ex_to(*self).get_representation_label(); + ex dim = ex_to(self->op(1)).get_dim(); + if (other->nops() > 1) + dim = minimal_dim(dim, ex_to(other->op(1)).get_dim()); + if (is_a(*other)) { - ex dim = ex_to(self->op(1)).get_dim(); + // Contraction only makes sense if the represenation labels are equal + if (ex_to(*other).get_representation_label() != rl) + return false; // gamma~mu gamma.mu = dim ONE if (other - self == 1) { @@ -258,15 +274,22 @@ bool diracgamma::contract_with(exvector::iterator self, exvector::iterator other *other = _ex1; return true; } + + } else if (is_a(other->op(0)) && other->nops() == 2) { + + // x.mu gamma~mu -> x-slash + *self = dirac_slash(other->op(0), dim, rl); + *other = _ex1; + return true; } return false; } /** Perform automatic simplification on noncommutative product of clifford - * objects. This removes superfluous ONEs, permutes gamma5's to the front + * objects. This removes superfluous ONEs, permutes gamma5/L/R's to the front * and removes squares of gamma objects. */ -ex clifford::simplify_ncmul(const exvector & v) const +ex clifford::eval_ncmul(const exvector & v) const { exvector s; s.reserve(v.size()); @@ -282,17 +305,67 @@ ex clifford::simplify_ncmul(const exvector & v) const bool something_changed = false; int sign = 1; - // Anticommute gamma5's to the front + // Anticommute gamma5/L/R's to the front if (s.size() >= 2) { exvector::iterator first = s.begin(), next_to_last = s.end() - 2; while (true) { exvector::iterator it = next_to_last; while (true) { exvector::iterator it2 = it + 1; - if (is_a(*it) && is_a(*it2) && !is_a(it->op(0)) && is_a(it2->op(0))) { - it->swap(*it2); - sign = -sign; - something_changed = true; + if (is_a(*it) && is_a(*it2)) { + ex e1 = it->op(0), e2 = it2->op(0); + + if (is_a(e2)) { + + if (is_a(e1) || is_a(e1)) { + + // gammaL/R gamma5 -> gamma5 gammaL/R + it->swap(*it2); + something_changed = true; + + } else if (!is_a(e1)) { + + // gamma5 gamma5 -> gamma5 gamma5 (do nothing) + // x gamma5 -> -gamma5 x + it->swap(*it2); + sign = -sign; + something_changed = true; + } + + } else if (is_a(e2)) { + + if (is_a(e1)) { + + // gammaR gammaL -> 0 + return _ex0; + + } else if (!is_a(e1) && !is_a(e1)) { + + // gammaL gammaL -> gammaL gammaL (do nothing) + // gamma5 gammaL -> gamma5 gammaL (do nothing) + // x gammaL -> gammaR x + it->swap(*it2); + *it = clifford(diracgammaR(), ex_to(*it).get_representation_label()); + something_changed = true; + } + + } else if (is_a(e2)) { + + if (is_a(e1)) { + + // gammaL gammaR -> 0 + return _ex0; + + } else if (!is_a(e1) && !is_a(e1)) { + + // gammaR gammaR -> gammaR gammaR (do nothing) + // gamma5 gammaR -> gamma5 gammaR (do nothing) + // x gammaR -> gammaL x + it->swap(*it2); + *it = clifford(diracgammaL(), ex_to(*it).get_representation_label()); + something_changed = true; + } + } } if (it == first) break; @@ -304,12 +377,6 @@ ex clifford::simplify_ncmul(const exvector & v) const } } - // Remove squares of gamma5 - while (s.size() >= 2 && is_a(s[0]) && is_a(s[1]) && is_a(s[0].op(0)) && is_a(s[1].op(0))) { - s.erase(s.begin(), s.begin() + 2); - something_changed = true; - } - // Remove equal adjacent gammas if (s.size() >= 2) { exvector::iterator it, itend = s.end() - 1; @@ -318,7 +385,14 @@ ex clifford::simplify_ncmul(const exvector & v) const ex & b = it[1]; if (!is_a(a) || !is_a(b)) continue; - if (is_a(a.op(0)) && is_a(b.op(0))) { + + const ex & ag = a.op(0); + const ex & bg = b.op(0); + bool a_is_diracgamma = is_a(ag); + bool b_is_diracgamma = is_a(bg); + + if (a_is_diracgamma && b_is_diracgamma) { + const ex & ia = a.op(1); const ex & ib = b.op(1); if (ia.is_equal(ib)) { // gamma~alpha gamma~alpha -> g~alpha~alpha @@ -326,15 +400,46 @@ ex clifford::simplify_ncmul(const exvector & v) const b = dirac_ONE(representation_label); something_changed = true; } - } else if (!is_a(a.op(0)) && !is_a(b.op(0))) { - const ex & ba = a.op(0); - const ex & bb = b.op(0); - if (ba.is_equal(bb)) { // a\ a\ -> a^2 - varidx ix((new symbol)->setflag(status_flags::dynallocated), ex_to(a.op(1)).get_dim()); - a = indexed(ba, ix) * indexed(bb, ix.toggle_variance()); - b = dirac_ONE(representation_label); - something_changed = true; - } + + } else if ((is_a(ag) && is_a(bg))) { + + // Remove squares of gamma5 + a = dirac_ONE(representation_label); + b = dirac_ONE(representation_label); + something_changed = true; + + } else if ((is_a(ag) && is_a(bg)) + || (is_a(ag) && is_a(bg))) { + + // Remove squares of gammaL/R + b = dirac_ONE(representation_label); + something_changed = true; + + } else if (is_a(ag) && is_a(bg)) { + + // gammaL and gammaR are orthogonal + return _ex0; + + } else if (is_a(ag) && is_a(bg)) { + + // gamma5 gammaL -> -gammaL + a = dirac_ONE(representation_label); + sign = -sign; + something_changed = true; + + } else if (is_a(ag) && is_a(bg)) { + + // gamma5 gammaR -> gammaR + a = dirac_ONE(representation_label); + something_changed = true; + + } else if (!a_is_diracgamma && !b_is_diracgamma && ag.is_equal(bg)) { + + // a\ a\ -> a^2 + varidx ix((new symbol)->setflag(status_flags::dynallocated), ex_to(a.op(1)).minimal_dim(ex_to(b.op(1)))); + a = indexed(ag, ix) * indexed(ag, ix.toggle_variance()); + b = dirac_ONE(representation_label); + something_changed = true; } } } @@ -342,17 +447,17 @@ ex clifford::simplify_ncmul(const exvector & v) const if (s.empty()) return clifford(diracone(), representation_label) * sign; if (something_changed) - return nonsimplified_ncmul(s) * sign; + return reeval_ncmul(s) * sign; else - return simplified_ncmul(s) * sign; + return hold_ncmul(s) * sign; } -ex clifford::thisexprseq(const exvector & v) const +ex clifford::thiscontainer(const exvector & v) const { return clifford(representation_label, v); } -ex clifford::thisexprseq(exvector * vp) const +ex clifford::thiscontainer(exvector * vp) const { return clifford(representation_label, vp); } @@ -379,14 +484,14 @@ ex dirac_gamma5(unsigned char rl) return clifford(diracgamma5(), rl); } -ex dirac_gamma6(unsigned char rl) +ex dirac_gammaL(unsigned char rl) { - return clifford(diracone(), rl) + clifford(diracgamma5(), rl); + return clifford(diracgammaL(), rl); } -ex dirac_gamma7(unsigned char rl) +ex dirac_gammaR(unsigned char rl) { - return clifford(diracone(), rl) - clifford(diracgamma5(), rl); + return clifford(diracgammaR(), rl); } ex dirac_slash(const ex & e, const ex & dim, unsigned char rl) @@ -413,13 +518,13 @@ static bool is_clifford_tinfo(unsigned ti) /** Take trace of a string of an even number of Dirac gammas given a vector * of indices. */ -static ex trace_string(exvector::const_iterator ix, unsigned num) +static ex trace_string(exvector::const_iterator ix, size_t num) { // Tr gamma.mu gamma.nu = 4 g.mu.nu if (num == 2) return lorentz_g(ix[0], ix[1]); - // Tr gamma.mu gamma.nu gamma.rho gamma.sig = 4 (g.mu.nu g.rho.sig + g.nu.rho g.mu.sig - g.mu.rho g.nu.sig + // Tr gamma.mu gamma.nu gamma.rho gamma.sig = 4 (g.mu.nu g.rho.sig + g.nu.rho g.mu.sig - g.mu.rho g.nu.sig ) else if (num == 4) return lorentz_g(ix[0], ix[1]) * lorentz_g(ix[2], ix[3]) + lorentz_g(ix[1], ix[2]) * lorentz_g(ix[0], ix[3]) @@ -435,8 +540,8 @@ static ex trace_string(exvector::const_iterator ix, unsigned num) exvector v(num - 2); int sign = 1; ex result; - for (unsigned i=1; i(e)) { - if (ex_to(e).get_representation_label() == rl - && is_a(e.op(0))) + if (!ex_to(e).get_representation_label() == rl) + return _ex0; + const ex & g = e.op(0); + if (is_a(g)) return trONE; + else if (is_a(g) || is_a(g)) + return trONE/2; else return _ex0; - } else if (is_ex_exactly_of_type(e, mul)) { + } else if (is_exactly_a(e)) { // Trace of product: pull out non-clifford factors ex prod = _ex1; - for (unsigned i=0; i(e)) { if (!is_clifford_tinfo(e.return_type_tinfo(), rl)) return _ex0; - // Expand product, if necessary - ex e_expanded = e.expand(); + // Substitute gammaL/R and expand product, if necessary + ex e_expanded = e.subs(lst( + dirac_gammaL(rl) == (dirac_ONE(rl)-dirac_gamma5(rl))/2, + dirac_gammaR(rl) == (dirac_ONE(rl)+dirac_gamma5(rl))/2 + )).expand(); if (!is_a(e_expanded)) return dirac_trace(e_expanded, rl, trONE); // gamma5 gets moved to the front so this check is enough bool has_gamma5 = is_a(e.op(0).op(0)); - unsigned num = e.nops(); + size_t num = e.nops(); if (has_gamma5) { @@ -492,42 +604,44 @@ ex dirac_trace(const ex & e, unsigned char rl, const ex & trONE) return _ex0; // Tr gamma5 gamma.mu gamma.nu gamma.rho gamma.sigma = 4I * epsilon(mu, nu, rho, sigma) + // (the epsilon is always 4-dimensional) if (num == 5) { ex b1, i1, b2, i2, b3, i3, b4, i4; base_and_index(e.op(1), b1, i1); base_and_index(e.op(2), b2, i2); base_and_index(e.op(3), b3, i3); base_and_index(e.op(4), b4, i4); - return trONE * I * (eps0123(i1, i2, i3, i4) * b1 * b2 * b3 * b4).simplify_indexed(); + return trONE * I * (lorentz_eps(ex_to(i1).replace_dim(_ex4), ex_to(i2).replace_dim(_ex4), ex_to(i3).replace_dim(_ex4), ex_to(i4).replace_dim(_ex4)) * b1 * b2 * b3 * b4).simplify_indexed(); } // Tr gamma5 S_2k = // I/4! * epsilon0123.mu1.mu2.mu3.mu4 * Tr gamma.mu1 gamma.mu2 gamma.mu3 gamma.mu4 S_2k + // (the epsilon is always 4-dimensional) exvector ix(num-1), bv(num-1); - for (unsigned i=1; i(idx1).replace_dim(_ex4), ex_to(idx2).replace_dim(_ex4), ex_to(idx3).replace_dim(_ex4), ex_to(idx4).replace_dim(_ex4)) * trace_string(v.begin(), num - 4); } } @@ -551,7 +665,7 @@ ex dirac_trace(const ex & e, unsigned char rl, const ex & trONE) } exvector iv(num), bv(num); - for (unsigned i=0; i(rhs) && rhs.return_type() == return_types::noncommutative && is_clifford_tinfo(rhs.return_type_tinfo())) { // Expand product, if necessary ex rhs_expanded = rhs.expand(); if (!is_a(rhs_expanded)) { - srl.let_op(i) = (lhs == canonicalize_clifford(rhs_expanded)); + srl[i] = (lhs == canonicalize_clifford(rhs_expanded)); continue; } else if (!is_a(rhs.op(0))) @@ -592,12 +707,12 @@ ex canonicalize_clifford(const ex & e) exvector v; v.reserve(rhs.nops()); - for (unsigned j=0; j(it->op(0))) + if (is_a(it->op(0)) || is_a(it->op(0)) || is_a(it->op(0))) ++it; while (it != next_to_last) { if (it[0].compare(it[1]) > 0) { @@ -611,7 +726,7 @@ ex canonicalize_clifford(const ex & e) it[0] = save1; it[1] = save0; sum -= ncmul(v, true); - srl.let_op(i) = (lhs == canonicalize_clifford(sum)); + srl[i] = (lhs == canonicalize_clifford(sum)); goto next_sym; } ++it;