Name: V. Shtabovenko Date: 06/09/18-03:26:25 PM Z

Hi,

after another 9 months, here is the solution. Sorry that I didn’t come
up with this immediately.

While working on something similar I remembered your question
and became curious whether your C0 indeed can be rewritten
as a linear combination of simpler integrals. In fact, already
the dependence on the kinematic invariants signals that this should
be possible, since there are not enough parameters for a “real”
triangle. So this triangle simply must be reducible into a tadpole and a
bubble.

One handy trick to achieve this is to use IBPs. We will need FeynHelpers
(github.com/FeynCalc/feynhelpers) for that:

$LoadAddOns = {“FeynHelpers”};
«FeynCalc`

Written as a loop integral, your C0[0, m^2, m^2/y, 0, 0, m^2]
corresponds to

FCClearScalarProducts[]
SPD[p1] = m^2;
SPD[p2] = 0;
SPD[p1, p2] = 1/2 m^2 - 1/2 m^2/y;

int = 1/(I Pi^2) FAD[k, {k + p1, m}, k + p2]

as one can easily check using ToPaVe:

(C0[0, m^2, m^2/y, 0, 0, m^2] - ToPaVe[int, k]) // PaVeOrder

Now using FIRE we obtain

res = FIREBurn[int, {k}, {p1, p2}] // FDS[#, k] & // ToPaVe[#, k] &

with res being

((-2 + D)*y*(1 + y)*A0[m^2])/(2*(-4 + D)*m^4*(-1 + y)^2)

  (2*(-3 + D)*y*B0[m^2/y, 0, m^2])/((-4 + D)*m^2*(-1 + y)^2)

This is the reduction formula you have been looking for.

Unfortunately, you cannot check this result using Package-X,
since here the Passarino-Veltman functions are multiplied with
1/(D-4) = 1/(2 eps), meaning that to obtain the O(eps^0) term,
the results for A0 and B0 must be expanded up to the order O(eps).
However, Package-X currently cannot not return higher order expansions
in eps.

Fortunately, the functions themselves are simple enough, so one can just
calculate them explicitly up to O(eps), which I did here (the result
for A0 is of course valid to all orders, for B0 I took the liberty
to expand the resulting hypergeometric function with HyperExp up to
O(eps)):

A0sol = -((((-I)*eta + m^2)^(1 - Epsilon)*ScaleMu^(2*Epsilon)*
        Gamma[-1 + Epsilon])/Pi^Epsilon);

B0sol = 1/Epsilon + 2 y - EulerGamma y + Log[4] - y Log[4] -
    Log[m^2] - Log[\[Pi]] + 2 Log[ScaleMu] - Log[1 - I eta - 1/y] +
    y Log[1 - I eta - 1/y] + PolyGamma[0, 3/2] - y PolyGamma[0, 3/2] +
    1/6 Epsilon (12 + 3 EulerGamma^2 - \[Pi]^2 +
       1/2 (6 EulerGamma^2 + \[Pi]^2) + 12 y -
       3 EulerGamma^2 y + \[Pi]^2 y + 6 EulerGamma Log[4] -
       6 EulerGamma y Log[4] + 3 Log[4]^2 - 3 y Log[4]^2 +
       3 Log[m^2]^2 + 6 Log[m^2] Log[\[Pi]] + 3 Log[\[Pi]]^2 +
       6 EulerGamma (Log[m^2] + Log[\[Pi]] - 2 Log[ScaleMu]) -
       12 Log[m^2 \[Pi]] Log[ScaleMu] + 12 Log[ScaleMu]^2 -
       3 Log[-I eta - 1/y]^2 + 3 y Log[-I eta - 1/y]^2

Notice that here I explicitly introduced the I eta prescription, since
depending on the range of y, the imaginary part will be different.
Package-X results are normally prepared in such a way, that they are
valid for all real values of y and are compatible with Mathematica’s
prescription to treat Log[-x] as Log[-x + I eta] when choosing the
branch. But when we calculate things by hand, we have to be more
careful, hence the explicit I eta.

For simplicity, let us consider the case were 0<y<1. Of course,
y could also take other values, but then one has to carefully perform
the analytic continuation for the logs and the polylog.

The corresponding rules for 0<y<1 are given by

rule1 = {
    Log[-I eta + m^2] :> Log[m^2],
    Log[-I eta + 1/(1 - y)] :> Log[1/(1 - y)],
    Log[-I eta - 1/y] :> Log[1/y] - I Pi,
    Log[1 - I eta - 1/y] :> Log[1/y - 1] - I Pi,
    PolyLog[2, -I eta + y] :> PolyLog[2, y]
    };

Now

tmp = Series[
     FCReplaceD[res, D -> 4 - 2 Epsilon] /. {A0[m^2] -> A0sol,
       B0[m^2/y, 0, m^2] -> B0sol}, {Epsilon, 0, 0}] // Normal;
ourRes = Simplify[tmp /. rule1 /. eta -> 0];

paxRes = PaXEvaluate[C0[0, m^2, m^2/y, 0, 0, m^2]];

diff = Simplify[(ourRes // FunctionExpand // PowerExpand //
       Expand) - (paxRes // FunctionExpand // PowerExpand // Expand)] //
    SimplifyPolyLog

(* 0 *)

and so we have shown that formula derived using IBPs is indeed correct.

BTW, while working this out, I noticed that there was a bug in
FCAbbreviate (which is required for FIREBurn) that got fixed in the
development version but somehow was not backported into the stable
version. I took care of that now

https://github.com/FeynCalc/feyncalc/commits/hotfix-stable

so please reinstall the stable version of FeynCalc before running the
above code.

Cheers,
Vladyslav

Am 26.09.2017 um 15:51 schrieb V. Shtabovenko:
> Hi,
>
> unfortunately, this is not possible with PaVeReduce (or other FeynCalc
> functions), since it does not  try to reduce basis integrals into
> something simpler (which is usually possible only in very special cases).
>
> Cheers,
> Vladyslav
>
> Am 24.09.2017 um 19:30 schrieb Chris:
>> I’d like to use the PaVeReduce function within FeynCalc in Mathematica
>>   to reduce a triangle integral down to bubbles and tadpoles. I found
>>   the wolfram help page about this function but I did not find what
>> all the options meant with the result that I was unable to produce
>>   the reduction I wanted.
>>
>> I have used other software for this reduction and I know what the answer
>>   is so I’m just playing about with FeynCalc at the moment. I tried
>>
>>       PaVeReduce[C0[0, m^2, m^2/y, 0, 0, m^2]] // TraditionalForm
>>
>> but this didn’t do the required reduction.  I played about with the
>> options too in
>>
>>       SetOptions[PaVeReduce, A0ToB0 -> True, BReduce -> True,
>> Collecting -> True, Dimension -> True, FCVerbose -> False, Factoring
>> -> Factor2, IsolateNames -> False, Mandelstam -> {}, PaVeAutoReduce ->
>> True, PaVeOrderList -> {}, WriteOutPaVe -> True]
>>
>> but couldn’t get the reduction to go ahead.
>>
>> Thanks for any comments! There is also the possibility that I am using
>> the wrong function because I know that Pass-Velt prescription is usually
>>   done for the reduction of tensor to scalar integrals and I’m trying
>> to do
>> a scalar to sum of simpler scalar integrals reduction.
>>
>