Name: Vladyslav Shtabovenko (email_not_shown)
Date: 11/07/14-01:55:52 PM Z


Hi,

glad that you figured it out yourself. For the sake of other people
reading this mailing list that might have similar concerns, I took the
liberty to answer your previous questions.

> SUNSimplify[SUNTrace[SUNT[i, j, i, j]], Explicit -> True] just gives
> -2/3; while SUNSimplify[SUNT[i, j, i, j], Explicit -> True] gives
> -2/9.why these two differ by a factor "3"?

The output is different, because in the first case you are computing
the trace of T^i T^j T^i T^j, while in the second case you just
simplify T^i T^j T^i T^j. In the former case you get a number,
  while in the latter case you get a number *times* the 3x3 unit matrix.
If you apply SUNTrace to SUNSimplify[SUNT[i, j, i, j], you will get
-(2/9)*3 = -2/3 where 3 comes from the trace of the unit matrix. Thus,

SUNSimplify[SUNTrace[SUNT[i, j, i, j]], SUNNToCACF -> False] and
SUNTrace[SUNSimplify[SUNT[i, j, i, j], SUNNToCACF -> False]] give you
the same result as it should be.

> As for the process(q,qbar->q,qbar),I guess we can just get the
> correct result by fixing the relative minus sign between two
> diagrams. It seems that,in my code, SUNSimplify can also make the
> color factor right, at least giving the right result.
> So DOES IT RIGHT OR WRONG?

It is wrong to ignore obvious mistakes only because the result looks
fine. SUNSimplify always expects that you apply it on a chain of T
matrices like T^A_ij T^B_jk T^C_kl. If you have something like T^A_ij
T^B_kl T^C_mn instead, you will obviously get a wrong result.
You can persuade yourself by looking at the q_i q_j -> q_i q_j
process. There you have the same issue and you will not get the correct
prefactor, unless you use that the amplitude is proportional to T^A_ik
T^A_jk and not to T^A.T^A.

> WHAT IF THERE ARE MORE TERMS CARRYING COLOR FACTORS, SHOULD WE JUST
> EVALUATE IT BY HAND NOW OR WE CAN MAKE IT SIMPLER?

If you have n external quarks that can carry different colors, your
amplitude will be proportional to n different fundamental indices. As I
previously stated, Feyncalc doesn't have bulit-in support for SUNT
matrices with explicit fundamental indices yet. However, since Feyncalc
runs on top of Mathematica it is not really difficult to make it handle
such objects properly in a given computation. Let me show how this can
be done.

The idea is to introduce a function SUNTE [ {x}, i,j] which corresponds
to T^x_ij, where x is the adjoint and i,j are fundamental color indices.
Since SUNTE defines a matrix element, it commutes with all other objects
and we don't need to care about DOT or commutators. Then you need to
define a replacement rule that can "sew" our SUNTE matrices together
when they have a common index, i.e. SUNTE [ {x}, i,j] SUNTE [ {y}, i,k]
will become SUNTE [ {x,y}, i,k]. If we want to obtain the complex
conjugate, we need to swap the fundamental indices. Finally, if both
fundamental indices are the same, then we have a trace, since SUNTE [
{x,y,z}, i,i] is nothing else than SUNTrace[SUNT[ x,y,z]. If you input
the amplitudes by hand, then you clearly need to make sure that you use
the correct indices everywhere. But the rest will be evaluated
automatically! Here is how one would modify your q qbar -> q qbar code
to use this approach.

----------------------------------------------------------------------
<< HighEnergyPhysics`FeynCalc`
SUNTESimplify[ex_] :=
   ex //. {SUNTE[{x__}, i_, j_] SUNTE[{y__}, j_, k_] :>
      SUNTE[{x, y}, i, k],
     SUNTE[{x__}, i_, i_] :>
      SUNSimplify[SUNTrace[SUNT[x]], Explicit -> True,
       SUNNToCACF -> False]};
SetMandelstam[s, t, u, p1, p2, -p3, -p4, 0, 0, 0, 0];
ScPr[p_, m_] := -I/(ScalarProduct[p] - m^2) // ExpandScalarProduct;
ftrace = {DiracTrace -> Tr2, D -> 4};
SUNN = 3;
SetOptions[SUNSimplify, SUNNToCACF -> False];
qav = 6;
f1 = (SpinorVBar[p2, 0].QGV[\[Alpha], a].SpinorU[p1, 0] ScPr[p1 + p2,
        0] SpinorUBar[p3, 0].QGV[\[Alpha], b].SpinorV[p4, 0] //
      Explicit) /. {SUNT[SUNIndex[a]] -> SUNTE[{a}, i, j],
     SUNT[SUNIndex[b]] -> SUNTE[{a}, l, k]};
f2 = -(SpinorUBar[p3, 0].QGV[\[Alpha], a].SpinorU[p1, 0] ScPr[p1 - p3,
          0] SpinorVBar[p2, 0].QGV[\[Alpha], b].SpinorV[p4, 0] //
       Explicit) /. {SUNT[SUNIndex[a]] -> SUNTE[{a}, i, k],
     SUNT[SUNIndex[b]] -> SUNTE[{a}, l, j]};
f1s = (SpinorUBar[p1, 0].QGV[\[Beta], a].SpinorV[p2,
         0] (-ScPr[p1 + p2, 0]) SpinorVBar[p4, 0].QGV[\[Beta],
         b].SpinorU[p3, 0] // Explicit) /. {SUNT[SUNIndex[a]] ->
      SUNTE[{b}, j, i], SUNT[SUNIndex[b]] -> SUNTE[{b}, k, l]};
f2s = -(SpinorUBar[p1, 0].QGV[\[Beta], a].SpinorU[p3,
          0] (-ScPr[p1 - p3, 0]) SpinorVBar[p4, 0].QGV[\[Beta],
          b].SpinorV[p2, 0] // Explicit) /. {SUNT[SUNIndex[a]] ->
      SUNTE[{b}, k, i], SUNT[SUNIndex[b]] -> SUNTE[{b}, j, l]};
f = f1 + f2;
fstar = f1s + f2s;
Msq = (1/(qav^2 Gstrong^4)) ((FermionSpinSum[f fstar] // Explicit //
           Expand) /. ftrace) // Contract // SUNTESimplify //
    SUNSimplify // Expand
standard = 4/9 ((s^2 + u^2)/t^2 + (u^2 + t^2)/s^2 - 2/3 u^2/(s t));
TrickMandelstam[Msq - standard, {s, t, u, 0}]
----------------------------------------------------------------------

You can automatize this even further if you use FeynArts to generate
your amplitudes. FeynArts always writes color matrices with explicit
fundamental indices, such that it is very simple to convert it to our
SUNTE. Here's an example of computing qg->qg that works with the current
development snapshot. You can also modify it to run with Feyncalc 8.2,
but there you don't have the new function for automatic renaming of
dummy indices , that I added only recently. Note that I also defined a
function InsertPolSum to do polarization
sums for gluons without bothering about Lorentz indices

----------------------------------------------------------------------
$LoadPhi = $LoadTARCER = False;
$LoadFeynArts = True;
<< HighEnergyPhysics`FeynCalc`
$FAVerbose = 0;
top = CreateTopologies[0, 2 -> 2];
diags =
     InsertFields[top, {F[3, {1}], V[5]} -> {F[3, {1}], V[5]},
    InsertionLevel -> {Classes},
       Model -> "SMQCD",
    ExcludeParticles -> {V[1], S[1], S[2], V[2]}];
Paint[diags, ColumnsXRows -> {3, 1}, Numbering -> None];
amps = Map[ReplaceAll[#, FeynAmp[_, _, amp_, ___] :> amp] &,
        Apply[List,
          FCPrepareFAAmp[CreateFeynAmp[diags,
             Truncated -> False,
        PreFactor -> 1]]]] //. {(a1__ DiracGamma[6] a2__ +
              a1__ DiracGamma[7] a2__) :> a1 a2,
     NonCommutative[x___] -> x,
        FermionChain -> DOT, DiracSpinor -> Spinor,
     FourMomentum[Incoming, 1] -> p1,
     FourMomentum[Incoming, 2] -> q1,
        FourMomentum[Outgoing, 1] -> p2,
     FourMomentum[Outgoing, 2] -> q2,
        Index[Lorentz, x_] :>

      LorentzIndex[ToExpression["Lor" <> ToString[x]]],
        Index[Gluon, x_] :>

      SUNIndex[ToExpression["Glu" <> ToString[x]]],
     SumOver[__] :> 1,
     SUNT[a_, i_, j_] :>
      SUNTE[{SUNIndex[a]}, SUNIndex[i], SUNIndex[j]], MU -> MQ,
     GaugeXi[g] -> GaugeXi,
     Conjugate[PolarizationVector][_, x_, y_] :>
      Conjugate[PolarizationVector[x, y, Transversality -> True]],
     PolarizationVector[_, x_, y_] :>
      PolarizationVector[x, y, Transversality -> True],
     Index[Colour, x_] :> ToExpression["Col" <> ToString[x]]};
SUNTESimplify[ex_] :=
   ex //. {SUNTE[{x__}, i_, j_] SUNTE[{y__}, j_, k_] :>
      SUNTE[{x, y}, i, k],
     SUNTE[{x__}, i_, i_] :>
      SUNSimplify[SUNTrace[SUNT[x]], Explicit -> True,
       SUNNToCACF -> False]};
InsertPolSum[ex_, mom_, auxmom_] :=
   ex //. {Pair[LorentzIndex[x_],
        Momentum[Polarization[mom, I, Transversality -> True]]] Pair[
        LorentzIndex[y_],
        Momentum[Polarization[mom, -I, Transversality -> True]]] :>
      PolarizationSum[x, y, mom, auxmom]};
SetMandelstam[s, t, u, p1, q1, -p2, -q2, 0, 0, 0, 0];
ampsMassless = amps // ReplaceAll[#, MQ -> 0] &;
sqAmpMassless = (1/(6*16)) Total[
                ampsMassless] (Total[ampsMassless] //
                   ComplexConjugate // FCRenameDummyIndices //
                 ReplaceAll[#,
                   SUNTE[{x__}, i_, j_] :> SUNTE[{x}, j, i]] &) //
              FermionSpinSum // InsertPolSum[#, q1, p1] & //
            InsertPolSum[#, q2, p2] & // Contract //
          PropagatorDenominatorExplicit //
         ReplaceAll[#,
           DiracTrace[x_] :>
            DiracTrace[x, DiracTraceEvaluate -> True]] & //
        SUNTESimplify //
       SUNSimplify[#, Explicit -> True, SUNNToCACF -> False] & //
      ReplaceAll[#, {SUNN -> 3, MQ -> 0}] & // Simplify //
    TrickMandelstam[#, {s, t, u, 0}] & // Expand
standard = ((s^2 + u^2)/t^2 - (4/9) (s^2 + u^2)/(s u)) Gstrong^4;
TrickMandelstam[sqAmpMassless - standard, {s, t, u, 0}]
----------------------------------------------------------------------

Cheers,
Vladyslav

On 06/11/14 17:08, Lingxiao Xu wrote:
> Hi,
> I'm very sorry to made a few mistakes in my previous message. As for the process on quark gluon scattering, there is a typo when defining the scalar propagator, ScalarProduct[p] just shouldn't be squared. I can get the correct answer without using SUNTrace in the last few steps, SUNSimplify is enough at that stage. I just did a few more related QCD processes, and I think I have been much more familiar with FeynCalc now. That is fine.
>
> Cheers!
>
> Lingxiao Xu
>



This archive was generated by hypermail 2b29 : 03/29/17-07:00:04 AM Z CEST