Evaluation of the finite part of the A0, B0 and C0 functions

$LoadPhi = True ; $LoadFeynArts = True ;

Needs["HighEnergyPhysics`FeynCalc`"] ;

FeynCalc 4.2.0
For help, type ?FeynCalc,
use the built-in help system
or visit www.feyncalc.org

Loading PHI

Loading FeynArts

FeynArts 3.1

by Hagen Eck, Sepp Kueblbeck, and Thomas Hahn

last revised 12 Feb 03

patched for use with FeynCalc by Frederik Orellana

PHI comes with the functions VeltmanB0 and VeltmanC0. VeltmanB0 is not really problematic. The implementation of VeltmanC0 is only a first attempt at implementing the formulae from 't Hooft and Veltman directly in Mathematica. It seems to be relatively successfull, but in general, it is recomended to use LoopTools for numerical evaluations of C0 as it is much more well tested.

•A0 and B0

TruncatedGamma[d, 0, 4] // Simplify

-1/12 (2 ÷J^3 + ÷J π^2 - 2 ψ^(2)(1)) d^2 + 1/12 (6 ÷J^2 + π^2) d - ÷J + 1/d

Plot[{Gamma[2 - d/2], TruncatedGamma[2 - d/2, 0, 2]}, {d, 0.0001, 17}, PlotStyle -> {{RGBColor[1, 0, 0]}, {RGBColor[0, 1, 0]}}] ;

[Graphics:HTMLFiles/index_11.gif]

Options[A0]

{A0ToB0 -> False}

SetOptions[A0, A0ToB0 -> False] ;

This is minus the definition of A _ 0 of Passarino and Veltman (equation D.1):

FeynAmpDenominator[PropagatorDenominator[Momentum[q1, D], ParticleMass[2]]]

1/(q _ 1^2 - (m _ 2^(ó  ))^2)

FeynCalc however, returns A _ 0, so the A _ 0of FeynCalc is minus the A _ 0of Passarino and Veltman:

oon = OneLoop[q1, %]

i π^2 A _ 0 ( (m _ 2^(ó  ))^2 )

SetOptions[A0, A0ToB0 -> True] ;

This is the definition of i π^2B _ 0 of Passarino and Veltman (equation D.2):

fad = FeynAmpDenominator[PropagatorDenominator[Momentum[q1, D], ParticleMass[2]], PropagatorDenominator[Momentum[q1, D] - Momentum[p, D], ParticleMass[1]]]

1/(q _ 1^2 - (m _ 2^(ó  ))^2) . ((q _ 1 - p)^2 - (m _ 1^(ó  ))^2)

FeynCalc agrees with Passarino and Veltman:

oon = OneLoop[q1, fad]

i π^2 B _ 0 (p^2, (m _ 1^(ó  ))^2, (m _ 2^(ó  ))^2)

PHI expands B _ 0according to equation (5.4.a) of appendix C of Donoghue, Golowich and Holstein:

VeltmanExpand[oon, MassScale -> 1, B0Evaluation -> "direct1", ExpandGammas -> False, TaylorOrder -> 1, DimensionExpand -> False] // Simplify

i π^(D/2) Γ (2 - D/2) Underoverscript[∫, 0, arg3] (x (m _ 1^(ó  ))^2 - (x - 1) (m _ 2^(ó  ))^2 - i ϵ + (x - 1) x p^2)^(D - 4)/2 d x

Or using the algorithm of Todd West, which gives the same result (after multiplying I^(D/2)=(-1)^((D-4)/2) on the integrand):

FeynmanParameterize[fad, q1] // Simplify

i i^D π^(D/2) (∫ _ 0^1 d x _ 1 ) . (-(x _ 1 - 1) x _ 1 p^2 - x _ 1 (m _ 1^(ó  ))^2 + x _ 1 (m _ 2^(ó  ))^2 - (m _ 2^(ó  ))^2)^(D - 4)/2 Γ (2 - D/2)

This is A _ 0of Passarino and Veltman ('t Hooft and Veltman section 3):

a0 = 1/(I * Pi^2) * I * Pi^(SpaceTimeDimensions/2)/((ParticleMass[1]^2))^(1 - SpaceTimeDimensions/2) * Gamma[1 - D/2]

π^(÷/2 - 2) Γ (1 - D/2) ((m _ 1^(ó  ))^2)^(÷/2 - 1)

$ExpansionQuantities = {δ} ;

This is the expanded A _ 0of Passarino and Veltman:

DiscardOrders[(((δ^2 * a0 // DimensionExpand[#, TaylorOrder -> 1] & // ExpandGammas[#, TaylorOrder -> 2] &) /. SpaceTimeDimensions -> D) /. D -> 4 - δ) /. _ParticleMass -> m, PerturbationOrder -> 2]/δ^2 // Simplify // Expand

log (m^2) m^2 - (2 m^2)/δ + log (π) m^2 + ÷J m^2 - m^2

This is the A _ 0of FeynCalc evaluated with PHI:

(VeltmanExpand[A0[m^2], MassScale -> 1, SmallEpsilon -> 0.00001, B0Evaluation -> "direct1", ExpandGammas -> False, TaylorOrder -> 1] // DimensionExpand[#, TaylorOrder -> 1] &) /. IntegrateHeld -> Integrate // Simplify

m^2 (1/4 Γ (2 - D/2) ((÷ - 4) log (m^2 - 0.00001` i) + 2) (log (π) ÷ - 4 log (π) + 2) + 1)

This is the expanded A _ 0of FeynCalc evaluated with PHI, exactly minus the above:

DiscardOrders[((((((δ^2 * A0[ParticleMass[m]^2] // VeltmanExpand[#, MassScale -> 1, B0Evaluation -> "direct1", ExpandGammas -> True, TaylorOrder -> 2, SmallEpsilon -> 0] &) /. IntegrateHeld -> Integrate) // DimensionExpand[#, TaylorOrder -> 1] &) /. SpaceTimeDimensions -> D) /. D -> 4 - δ)) /. _ParticleMass -> m, PerturbationOrder -> 2]/δ^2 // Simplify // Expand

-log (m^2) m^2 + (2 m^2)/δ - log (π) m^2 - ÷J m^2 + m^2

With Δ = -2/(D - 4)+ γ -ln(π), the A _ 0(m^2) of LoopTools is -A _ 0^PaVe(m^2) - Δ m^2, where A _ 0^PaVeis the A _ 0of Passarino and Veltman (which is minus the A _ 0 of FeynCalc):

Notice: To load LoopTools, get it, and change the path appropiately. Loading it makes A0 and B0 (and D0 and E0) return explicit values.

looptools = Install["LoopTools"] ;

A0[1]

A0[2]

2 - 2 Log[2] // N

0.6137056388801094`

The B _ 0of LoopTools is the B _ 0^PaVe-Δ :

Here is the definition of Passarino and Veltman of  B _ 0^PaVe-Δ.  The logarithm is to be taken just below the real axis:

Plot3D[Im[Log[x + I * y]], {x, -1, 1}, {y, -1, 1}] ;

[Graphics:HTMLFiles/index_72.gif]

B0[1, 0, 0]

2.` + 3.14159265358979311` i

-NIntegrate[Log[1 x^2 - 1 x - i 0.00000001], {x, 0, 1}]

1.9999999748918027` + 3.1415922547705755` i

B0[2, 0, 0]

1.3068528194400546` + 3.141592653589793` i

-NIntegrate[Log[2 x^2 - 2 x - i 0.00000001], {x, 0, 1}]

1.3068528103291022` + 3.141592451116708` i

Uninstall[looptools] ;

The VeltmanB0 of PHI returns an explicit expression for the B0 of FeynCalc.  VeltmanDelta[4-D] is similar to the Δ above, but with -γ instead of γ (for some reason my expansion of the gamma function gives this -γ):

v1 = (VeltmanB0[1, 0, 0, B0Evaluation -> "direct1", SmallEpsilon -> 0.000001, DimensionExpand -> True, FCIntegrate -> NIntegrate, MassScale -> 1, ExpandGammas -> True]) /. D -> 4 - δ // Simplify

(((0.9999983997198449` + 1.5707814638053907` i) δ + 1) (÷J δ - 2) (δ log (π) - 2))/(2 δ)

Limit[v1 - VeltmanDelta[δ], δ -> 0] // N

1.9999967994396899` + 3.1415629276107815` i

v2 = (VeltmanB0[2, 0, 0, B0Evaluation -> "direct1", SmallEpsilon -> 0.000001, DimensionExpand -> True, FCIntegrate -> NIntegrate, MassScale -> 1, ExpandGammas -> True]) /. D -> 4 - δ // Simplify

(((0.6534256640586659` + 1.570788542178852` i) δ + 1) (÷J δ - 2) (δ log (π) - 2))/(2 δ)

Limit[v2 - VeltmanDelta[δ], δ -> 0] // N

1.3068513281173317` + 3.141577084357704` i

•C0

This is minus the definition of i π^2C _ 0 of Passarino and Veltman (equation E.1):

FeynAmpDenominator[PropagatorDenominator[Momentum[q1, D], ParticleMass[1]], PropagatorDenominator[Momentum[q1, D] - Momentum[p1, D], ParticleMass[2]], PropagatorDenominator[Momentum[q1, D] - Momentum[p1, D] - Momentum[p2, D], ParticleMass[3]]]

1/(q _ 1^2 - (m _ 1^(ó  ))^2) . ((q _ 1 - p _ 1)^2 - (m _ 2^(ó  ))^2) . ((-p _ 1 - p _ 2 + q _ 1)^2 - (m _ 3^(ó  ))^2)

FF (LoopTools) follows Passarino and Veltman, whereas FeynCalc's definition is minus the definition of Passarino and Veltman:

oon = OneLoop[q1, %]

i π^2 C _ 0 ( p _ 1^2 , p _ 2^2 , p _ 1^2 + 2 p _ 1 · p _ 2 + p _ 2^2 , (m _ 1^(ó  ))^2 , (m _ 2^(ó  ))^2 , (m _ 3^(ó  ))^2 )

Plot3D[Im[Spence[x + I * y]], {x, -1, 3}, {y, -1, 1}, PlotPoints -> 20] ;

[Graphics:HTMLFiles/index_98.gif]

Plot3D[Re[Spence[x + I * y]], {x, -1, 3}, {y, -1, 1}, PlotPoints -> 20] ;

[Graphics:HTMLFiles/index_100.gif]

Plot[Re[Spence[x]], {x, -1, 3}] ;

[Graphics:HTMLFiles/index_102.gif]

f[p12_, p20_] := VeltmanC0[10, p20, p12, 1, 1, 1, C0Evaluation -> "Spence", SmallEpsilon -> 0.0000001]

Plot3D[Re[f[x, y]], {x, -100, 100}, {y, -100, 100}, PlotPoints -> 20] ;

[Graphics:HTMLFiles/index_105.gif]

Plot3D[Im[f[x, y]], {x, -100, 100}, {y, -100, 100}, PlotPoints -> 20] ;

[Graphics:HTMLFiles/index_107.gif]

This is a sample infrared FF (LoopTools) plot:

These are sample infrared FF (LoopTools) plots and PHI plots with Spence evaluation and the simpler Infrared evaluations (also using Spence functions, but only two):

looptools = Install["LoopTools"] ;

Plot[Re[C0[200, 700, 400, 200, d, 700]], {d, 0.01, 3}] ;

[Graphics:HTMLFiles/index_110.gif]

Plot[{-Re[VeltmanC0[200, 700, 400, 200, d, 700, C0Evaluation -> "infrared", SmallEpsilon -> 0.00001]], -Re[VeltmanC0[200, 700, 400, 200, d, 700, C0Evaluation -> "Spence", SmallEpsilon -> 0.00001]]}, {d, 0.01, 3}, PlotStyle -> {{RGBColor[1, 0, 0]}, {RGBColor[0, 1, 0]}, {RGBColor[0, 0, 1]}}] ;

[Graphics:HTMLFiles/index_112.gif]

Plot[Im[C0[200, 700, 400, 200, d, 700]], {d, 0.01, 3}] ;

[Graphics:HTMLFiles/index_114.gif]

Plot[{-Im[VeltmanC0[200, 700, 400, 200, d, 700, C0Evaluation -> "infrared", SmallEpsilon -> 0.00001]], -Im[VeltmanC0[200, 700, 400, 200, d, 700, C0Evaluation -> "Spence", SmallEpsilon -> 0.00001]]}, {d, 0.01, 3}, PlotStyle -> {{RGBColor[1, 0, 0]}, {RGBColor[0, 1, 0]}, {RGBColor[0, 0, 1]}}] ;

[Graphics:HTMLFiles/index_116.gif]

Plot[Re[C0[200, 200, 4000, 200, d, 200]], {d, 0.01, 3}] ;

[Graphics:HTMLFiles/index_118.gif]

Plot[{-Re[VeltmanC0[200, 200, 4000, 200, d, 200, C0Evaluation -> "infrared", SmallEpsilon -> 0.00001]], -Re[VeltmanC0[200, 200, 4000, 200, d, 200, C0Evaluation -> "infrared2", SmallEpsilon -> 0.00001, ExplicitLeutwylerSigma -> True]], -Re[VeltmanC0[200, 200, 4000, 200, d, 200, C0Evaluation -> "Spence", SmallEpsilon -> 0.00001]]}, {d, 0.01, 3}, PlotStyle -> {{RGBColor[1, 0, 0]}, {RGBColor[0, 1, 0]}, {RGBColor[0, 0, 1]}}] ;

[Graphics:HTMLFiles/index_120.gif]

Plot[Im[C0[200, 200, 8000, 200, d, 200]], {d, 0.01, 3}] ;

[Graphics:HTMLFiles/index_122.gif]

Plot[{-Im[VeltmanC0[200, 200, 8000, 200, d, 200, C0Evaluation -> "infrared", SmallEpsilon -> 0.00001]], -Im[VeltmanC0[200, 200, 8000, 200, d, 200, C0Evaluation -> "infrared2", SmallEpsilon -> 0.00001, ExplicitLeutwylerSigma -> True]], -Im[VeltmanC0[200, 200, 8000, 200, d, 200, C0Evaluation -> "Spence", SmallEpsilon -> 0.00001]]}, {d, 0.01, 3}, PlotStyle -> {{RGBColor[1, 0, 0]}, {RGBColor[0, 1, 0]}, {RGBColor[0, 0, 1]}}] ;

[Graphics:HTMLFiles/index_124.gif]

Sample valuation with FF (LoopTools):

C0[2000, 400, 6000, 2005, 400, 800]

-0.0015663632227236749` - 0.0011843851395765958` i

Uninstall[looptools] ;

The different numeric evaluations of PHI are generally unreliable:

-VeltmanC0[2000, 400, 6000, 2005, 400, 800, C0Evaluation -> "direct1", SmallEpsilon -> 0.000000001]

NIntegrate :: slwcon : Numerical integration converging too slowly; suspect one of the following: singularity, value of the integration being 0, oscillatory integrand, or insufficient WorkingPrecision. If your integrand is oscillatory try using the option Method->Oscillatory in NIntegrate.

NIntegrate :: ncvb : NIntegrate failed to converge to prescribed accuracy after 13 recursive bisections in \!\n\(TraditionalForm\`HighEnergyPhysics`Phi`Renormalization`Private`x\)\n near \!\n\(TraditionalForm\`\({HighEnergyPhysics`Phi`Renormalization`Private\\\n`x, \(\(<< 47 >>\)\)}\)\)\n = \!\n\(TraditionalForm\`\({0.54949951171875`, 0.3874400854110718`}\)\)\n.

-0.00184662105375513` - 4.0961235263794064`*^-11 i

-VeltmanC0[2000, 400, 6000, 2005, 400, 800, C0Evaluation -> "direct2", SmallEpsilon -> 0.000000001]

NIntegrate :: ncvb : NIntegrate failed to converge to prescribed accuracy after 7 recursive bisections in \!\n\(TraditionalForm\`HighEnergyPhysics`Phi`Renormalization`Private`y\)\n near \!\n\(TraditionalForm\`HighEnergyPhysics`Phi`Renormalization`Private`y\)\n = 0.55859375` .

-0.0015647409211476436` - 0.0011850678318585692` i

-VeltmanC0[2000, 400, 6000, 2005, 400, 800, C0Evaluation -> "direct3", SmallEpsilon -> 0.00000000001] // N

NIntegrate :: ncvb : NIntegrate failed to converge to prescribed accuracy after 7 recursive bisections in \!\n\(TraditionalForm\`HighEnergyPhysics`Phi`Renormalization`Private`y\)\n near \!\n\(TraditionalForm\`HighEnergyPhysics`Phi`Renormalization`Private`y\)\n = 0.55859375` .

-0.0015647409206498435` - 0.0011850678318606799` i

Direct4 fails in this region of parameter space because Mathematica does not automatically implement the right cut:

-VeltmanC0[2000, 400, 6000, 2005, 400, 800, C0Evaluation -> "direct4", SmallEpsilon -> 0.00000000001] // N

-0.004212289375722643` - 0.001264006526891126` i

Spence is the most generally reliable and fast of the PHI options:

-VeltmanC0[2000, 400, 6000, 2005, 400, 800, C0Evaluation -> "Spence", SmallEpsilon -> 0.00000000001] // N

-0.0015663632227236276` - 0.0011843851395765817` i

Converted by Mathematica  (July 10, 2003)