+ex dirac_trace(const ex & e, unsigned char rl, const ex & trONE)
+{
+ if (is_a<clifford>(e)) {
+
+ if (ex_to<clifford>(e).get_representation_label() == rl
+ && is_a<diracone>(e.op(0)))
+ return trONE;
+ else
+ return _ex0;
+
+ } else if (is_exactly_a<mul>(e)) {
+
+ // Trace of product: pull out non-clifford factors
+ ex prod = _ex1;
+ for (unsigned i=0; i<e.nops(); i++) {
+ const ex &o = e.op(i);
+ if (is_clifford_tinfo(o.return_type_tinfo(), rl))
+ prod *= dirac_trace(o, rl, trONE);
+ else
+ prod *= o;
+ }
+ return prod;
+
+ } else if (is_exactly_a<ncmul>(e)) {
+
+ if (!is_clifford_tinfo(e.return_type_tinfo(), rl))
+ return _ex0;
+
+ // Expand product, if necessary
+ ex e_expanded = e.expand();
+ if (!is_a<ncmul>(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<diracgamma5>(e.op(0).op(0));
+ unsigned num = e.nops();
+
+ if (has_gamma5) {
+
+ // Trace of gamma5 * odd number of gammas and trace of
+ // gamma5 * gamma.mu * gamma.nu are zero
+ if ((num & 1) == 0 || num == 3)
+ return _ex0;
+
+ // Tr gamma5 gamma.mu gamma.nu gamma.rho gamma.sigma = 4I * epsilon(mu, nu, rho, sigma)
+ 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();
+ }
+
+ // Tr gamma5 S_2k =
+ // I/4! * epsilon0123.mu1.mu2.mu3.mu4 * Tr gamma.mu1 gamma.mu2 gamma.mu3 gamma.mu4 S_2k
+ exvector ix(num-1), bv(num-1);
+ for (unsigned i=1; i<num; i++)
+ base_and_index(e.op(i), bv[i-1], ix[i-1]);
+ num--;
+ int *iv = new int[num];
+ ex result;
+ for (unsigned i=0; i<num-3; i++) {
+ ex idx1 = ix[i];
+ for (unsigned j=i+1; j<num-2; j++) {
+ ex idx2 = ix[j];
+ for (unsigned k=j+1; k<num-1; k++) {
+ ex idx3 = ix[k];
+ for (unsigned l=k+1; l<num; l++) {
+ ex idx4 = ix[l];
+ iv[0] = i; iv[1] = j; iv[2] = k; iv[3] = l;
+ exvector v;
+ v.reserve(num - 4);
+ for (unsigned n=0, t=4; n<num; n++) {
+ if (n == i || n == j || n == k || n == l)
+ continue;
+ iv[t++] = n;
+ v.push_back(ix[n]);
+ }
+ int sign = permutation_sign(iv, iv + num);
+ result += sign * eps0123(idx1, idx2, idx3, idx4)
+ * trace_string(v.begin(), num - 4);
+ }
+ }
+ }
+ }
+ delete[] iv;
+ return trONE * I * result * mul(bv);
+
+ } else { // no gamma5
+
+ // Trace of odd number of gammas is zero
+ if ((num & 1) == 1)
+ return _ex0;
+
+ // Tr gamma.mu gamma.nu = 4 g.mu.nu
+ if (num == 2) {
+ ex b1, i1, b2, i2;
+ base_and_index(e.op(0), b1, i1);
+ base_and_index(e.op(1), b2, i2);
+ return trONE * (lorentz_g(i1, i2) * b1 * b2).simplify_indexed();
+ }
+
+ exvector iv(num), bv(num);
+ for (unsigned i=0; i<num; i++)
+ base_and_index(e.op(i), bv[i], iv[i]);
+
+ return trONE * (trace_string(iv.begin(), num) * mul(bv)).simplify_indexed();
+ }
+
+ } else if (e.nops() > 0) {
+
+ // Trace maps to all other container classes (this includes sums)
+ pointer_to_map_function_2args<unsigned char, const ex &> fcn(dirac_trace, rl, trONE);
+ return e.map(fcn);
+
+ } else
+ return _ex0;
+}