Name: Vladyslav Shtabovenko Date: 02/20/16-09:23:33 PM Z

Hi Xing,

The short answer: the problem with your code is the D->4 limit, that you
are actually not
allowed to take. The B0 function is UV divergent, so by putting D to 4 you
are loosing a contribution to the finite part which leads to the
discrepancy.

The long answer:

First let me observe, that if you evaluate PaVeReduce
with the global option $LimitTo4 set to False, tid1 and tid2 are apparently
the same:

FCClearScalarProducts[];
SPD[p1, p1] = 0;
SPD[p2, p2] = 0;
SPD[p1, p2] = s/2;
tid1 = (ToPaVe[
    TID[FV[q, mu] FV[q, nu] FAD[{q, m}, {q + p1, m}, {q + p2, m}], q,
     UsePaVeBasis -> False], q]);
tid2 = (ToPaVe[
    TID[FV[q, mu] FV[q, nu] FAD[{q, m}, {q + p1, m}, {q + p2, m}], q,
     UsePaVeBasis -> True], q]);
res = Simplify[tid1 - tid2]

$LimitTo4 = False;
res // PaVeReduce

-> 0

Otherwise, you obtain

$LimitTo4 = True;
res // PaVeReduce // Simplify //FCE

((-I/4)*Pi^2*(-2 + D + (-4 + D)*B0[-s, m^2, m^2] +
   2*(-4 + D)*m^2*C0[0, 0, -s, m^2, m^2, m^2])*
  (-2*(FVD[p1, nu]*FVD[p2, mu] + FVD[p1, mu]*FVD[p2, nu]) + s*MTD[mu, nu]))/
 ((-2 + D)*s)

As you have observed, this result doesn’t vanish when you put D to 4.
This is expected,
since the B0 function is of course UV divergent and produces a
1/Epsilon pole. When you
set D=4, you are missing all the terms of order D/Epsilon which are not
vanishing for
D= 4-2Epsilon (or 4-Epsilon, whatever you prefer). To see that the
output is indeed zero,
as it should be, one has to compute the integrals explicitly.

At this point I would like to explain the meaning of the $LimitTo4
option, since many people
seem to be confused by it. A general Passarino-Veltman coefficient
function PaVe might be
UV-divergent. Hence, we can parametrize it as

PaVe = a/(D-4) + b + O(Epsilon), where

b is the finite part (0th order term in the Epsilon expansion) and a is
the prefactor of the 1/Epsilon pole.
At 1-loop we don’t care about terms that are higher order in Epsilon, so
the Epsilon-expansion is truncated here.

Now, in the reducton of PaVe-functions to scalar functions
(A0,B0,C0,D0), which is done
using Equations from the Section 4.2 of arXiv:0709.1075, these
PaVe-functions can be multiplied
by coefficients that are rational functions in D, e.g. D, 1/(D-2), 1/D
etc. Let us denote such a coefficient
as f(D). Then, again we can parametrize it as

f(D) = f(4) + f’(4) (D-4) + O(Epsilon^2),

where f’(4) is the derivative of f(D) w.r.t to D-4 evaluated at D=4.
Notice that here I expanded f(D) up to second order in Epsilon (actually
in D-4), since when I multiply it with a PaVe, the linear term f’(4)
(D-4) multiplied by the a/(D-4) term will produce a term finite in the
D->4 limit.

So I can write

f(D) PaVe = (f(4) + f’(4) (D-4)+ O(Epsilon)^2 )(a/(D-4) + b +
O(Epsilon)) =

f(4)(a/(D-4) + b) + a f’(4) + O(Epsilon) =

f(4) PaVe + a f’(4) + O(Epsilon).

Obviously, if I know the prefactor a of the 1/Epsilon pole of a PaVe
function, then I
can safely rewrite the product f(D)*PaVe as f(4)*PaVe + some finite
part. This is a completely
general statement in dimensional regularization that doesn’t depend on a
scheme etc.
Of course, these 1/Epsilon pole coefficients of PaVe functions are well
known and can
be found in the literature, e.g. in the Appendix A of
arXiv:hep-ph/0509141. FeynCalc knows
some of them and can therefore simplify certain f(D)*PaVe products, when
the options $LimitTo4 is set
to True. It is also clear that when we write f(4)*PaVe, the PaVe
function itself still has to
be computed using dimensional regularization and will exhibit a
1/Epsilon pole. On the other hand,
when $LimitTo4 is set to False, no simplifications of f(D)*PaVe can occur.

All this discussion applies for Passarino-Veltman functions that are IR
finite. This is because
in dim reg, IR divergences are usually regulated in the same way as UV
divergences, so that one
cannot distinguish between the two. An IR divergene would modify the
value of 1/Epsilon pole
coefficient which would invalidate the whole approach. So,
$LimitTo4=True should not be used
for IR divegent loop integrals, unless the IR divergence is regulated in
a different way (i.e. with
a fictitious mass). This doesn’t apply to your case, as your integral is
IR finite.

Coming back to you problem, there is in fact also an automatic way to
see that the differnce between
tid1 and tid2 vanishes also in the case when we use PaVeReduce with
$LimitTo4=True. Hiren Patel’s
Package-X (https://packagex.hepforge.org/) contains a library of
analytic results of PaVe functions
with up to three legs (i.e. A, B and C-functions).

My add-on FeynHelpers (https://github.com/FeynCalc/feynhelpers) can call
Package-X directly from FeynCalc in a transparent way. To install it, use

Import[“https://raw.githubusercontent.com/FeynCalc/feynhelpers/master/install.m”]
InstallFeynHelpers[]

Then restart Mathematica and execute

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

FCClearScalarProducts[];
SPD[p1, p1] = 0;
SPD[p2, p2] = 0;
SPD[p1, p2] = s/2;
tid1 = (ToPaVe[
    TID[FV[q, mu] FV[q, nu] FAD[{q, m}, {q + p1, m}, {q + p2, m}], q,
     UsePaVeBasis -> False], q]);
tid2 = (ToPaVe[
     TID[FV[q, mu] FV[q, nu] FAD[{q, m}, {q + p1, m}, {q + p2, m}], q,
       UsePaVeBasis -> True], q]) // PaVeReduce;
res = Simplify[tid1 - tid2]

PaXEvaluate[res]

which returns 0.

Of course, you can also evaluate tid1 and tid2 separatly, if you want to
see explicitly
that they are the same

r1 = PaXEvaluate[tid1]
r2 = PaXEvaluate[tid2]
Simplify[r1 - r2]

which gives you zero as expected.

Cheers,
Vladyslav.

Am 19.02.2016 um 20:58 schrieb Xing:
> Hi Vladyslav,
> When I tried to do TID to a rank-2 3-point loop tensor, TID with UsePaVeBasis set to be true or false give me different results (tid2-tid1 doesn’t vanish). Do you know why this happens.
>
> In[24]:=
> ClearScalarProducts;
> SPD[p1, p1] = 0;
> SPD[p2, p2] = 0;
> SPD[p1, p2] = s/2;
> tid1 = (ToPaVe[
> TID[FV[q, mu] FV[q, nu] FAD[{q, m}, {q + p1, m}, {q + p2, m}],
> q, UsePaVeBasis -> False], q] /. D -> 4);
> tid2 = (ToPaVe[
> TID[FV[q, mu] FV[q, nu] FAD[{q, m}, {q + p1, m}, {q + p2, m}],
> q, UsePaVeBasis -> True], q] /. D -> 4 // PaVeReduce);
> FullSimplify[tid1 - tid2]
>
> Out[30]= -((I \[Pi]^2 (s Overscript[g, _]^(munu)-2 (Overscript[p2, _]^mu Overscript[p1, _]^nu+Overscript[p1, _]^mu Overscript[p2, _]^nu)))/(4 s))
>
>
> Cheers,
> Xing
>