Very long expressions in loop calculations

[moatms]

Hello,

I am trying to calculate the amplitude of gg->hZ at one loop (with only top quarks in the loop) using FeynCalc and FeynArts, but I obtain gigantic expressions (the output file with the final expression has a size of 59 MB). Then if I try to do anything on these expressions to simplify them, my notebook runs for longer than overnight and is not able to simplify the expression or do a series on it...
There is a good example on how to optimize FeynCalc for loops in https://inspirehep.net/files/c9eedd22ad7cc1c29639579930f7a680 (pages 52 and 74) and that helped me a lot already but I couldn't find any other example to help me optimize my code.
Do you know of any other example for loop processes or can you spot anything that could be done to simplify my code and the expressions I get?
Here is what I do:

AmpFA = CreateFeynAmp[diags, Truncated -> False];

where diags are the diagrams I am evaluating, so here only the 6 box diagrams for gg->hZ with top quarks in the box. I keep the masses of the top, Higgs and Z different from zero.

AmpFA = AmpFA /. PolarizationVector -> FAPolarizationVector;

AmpFC = FCFAConvert[AmpFA, IncomingMomenta -> {p1, p2}, OutgoingMomenta -> {p3, p4}, LoopMomenta -> {k},
 List -> False, Contract -> True, ChangeDimension -> D, DropSumOver -> True, UndoChiralSplittings -> True, 
TransversePolarizationVectors ->{p1, p2}] // FCTraceFactor // SUNSimplify // Simplify // DiracSimplify ;

step0 = (Collect2[AmpFC // Contract // DotSimplify // DiracEquation // PowerExpand //Expand, SMP["m_t"], 
DiracSpinor, Factoring --> Simplify]) // Simplify;

step1 = step0b // FeynAmpDenominatorSimplify[#, k] & // Collect2[#, SMP["m_t"], FAD, DiracSpinor, 
Factoring -> FullSimplify] & ;

step2 = ApartFF[step1, {k}] // DotSimplify // DiracSimplify // DiracEquation // FullSimplify;

step3 = step2 // Collect2[#, FAD, SMP["m_t"], DiracSpinor,  Factoring -> Simplify] & // Simplify;

step4 = TID[step3, k, UsePaVeBasis -> True, ToPaVe -> True] // PropagatorDenominatorExplicit[#] & 
// DiracEquation //DiracSimplify // Contract // DotSimplify // Expand
// Collect2[#, PaVe, A0, B0, C0, D0, IsolateNames -> KK, Factoring -> Simplify] & // Simplify;

step5 = step4 // PaVeReduce// FRH//DiracSimplify;

step6= step5 // Collect2[#, PaVe, A0, B0, C0, D0, Factoring -> Simplify] &;

step7=PaXEvaluate[step6, k, PaXD0Expand -> True, PaXSeries -> {{SMP["m_H"], 0, 2}, {SMP["m_Z"], 0, 2}}, 
PaXAnalytic -> True,PaXC0Expand->True];

step8 = step9 // ChangeDimension[#, 4] &

step10=step9//DiracSimplify;

Thanks a lot!

[zxz12m]

Hi, thanks for mentioning my thesis.
Most of this simplification is hardly predictable. I played around with different ideas on how to reduce the number of terms checking of results with LeafCount[%] function. The second trick is isolating all possible structures. For example, if you work with PaVe functions, try to isolate the Dirac structures.

In your code, I don't think that is correct to expand around masses of Higgs and Z boson. Usually in this case one needs to find some ratio of masses like m_b\m_W. Another possible solution is to expand not around 0, but around the masses of searching bosons.

Anyway, D -functions are very complicated, and very often it is not possible to obtain a nice and readable analytic expression. Moreover, polylogs are very unstable for evaluation in Mathematica, and we for example in our paper 2001.06516 evaluated this functions only numerically, and presented the analytic result in terms of Passarino-Veltman functions.

[vsht]

In addition to what have been said above, I would also

• calculate each diagram separately in a separate notebook or even better in a .m file, so that it can be parallelized on a cluster
• use the FCVerbose->1 option and wrap assignments with AbsoluteTiming to find out which manipulations turn out to be particularly slow
• avoid Simplify and FullSimplify, unless the expressions to which they are applied are sufficiently small

[moatms]

Many thanks for the ideas, I'm going to try them!