To remain closer to textbook notation, display the imaginary unit with a lowercase
>
|
interface(imaginaryunit = i):
|
The simplest case of a massive field, the integral containing two propagators and one external momentum to which corresponds the mass .
>
|
%FeynmanIntegral(p__1[~mu]/((p__1^2 - m__phi^2 + i * epsilon)*((p__1 - P__1)^2 - m__1^2 + i * epsilon)), p__1);
|
The reduction of this tensor integral to a linear combination of scalar Feynman integrals all in one go:
>
|
(2) = TensorReduce((2));
|
Note that, by design, the reduction process does not evaluate the integrals so that one can follow the reduction process clearly. The evaluation can be performed next by passing this result to Evaluate
>
|
(2) = Evaluate(rhs((3)));
|
Note also that Evaluate automatically calls TensorReduce to perform the reduction of tensor integrals when that is the case. So, passing the Feynman integral directly to Evaluate, skipping the interactive TensorReduce step, results in the same
Back to the reduction process, this is how the integral is processed one step at a time. First, check the abstract representation that will be used in the output step by step:
>
|
ToAbstractRepresentation((2));
|
In this output we see the integral has 2 propagators, the first one has 0 external momentum (i.e. none) and mass . The second propagator has external momentum to which corresponds the mass . Finally the loop momentum integration variable is and the last operand, in this example equal to 0 means there are no contracted powers of , the loop integration variable, in the numerator of the integrand. To retrieve the non-abstract form from the abstract one you can use
>
|
FromAbstractRepresentation((6));
|
The first step of the Passarino-Veltman reduction, the main equation
>
|
TensorReduce((2), step = 1);
|
The right-hand side contains only one element. That is so because the tensor basis for this problem, where there is only one free spacetime index in the numerator of the integral and only one external momentum is given by just
>
|
TensorBasis([P__1], [~mu]);
|
The second step
>
|
TensorReduce((2), step = 2);
|
The third step only represents the scalar products in the right-hand side in a more convenient form
>
|
TensorReduce((2), step = 3);
|
The fourth step is the most important one, where the actual reduction to scalar integrals, represented in abstract form, is performed
>
|
TensorReduce((2), step = 4);
|
To see this result in standard representation you can use
>
|
FromAbstractRepresentation((12));
|
The fifth step processes this output by solving for the coefficients, expressing them in terms of the scalar integrals of step 4.
>
|
TensorReduce((2), step = 5);
|
The sixth step combines this result inserting, in the output of step 1, the values of the
>
|
TensorReduce((2), step = 6);
|
Finally, either passing step = 7 or omitting the step = ... altogether, the whole reduction is performed as done at the beginning (see equation (3)).
An example with two free indices
>
|
%FeynmanIntegral(p__1[~mu]*p__1[~nu]/((p__1^2 - m__1^2 + I*epsilon)*((p__1 - P__1)^2 - m__1^2 + i*epsilon)), p__1);
|
The reduction of this tensor integral to scalar integrals is given by
>
|
(16) = TensorReduce((16));
|
To understand this result, start checking the tensor basis, which in this case involves two objects
>
|
TensorBasis([P__1], [~mu, ~nu]);
|
The key steps are 1, 2 and 4. Step 1 gives the expansion of the integral onto the tensor basis
>
|
TensorReduce((16), step = 1);
|
Step 2 shows the system of equations; in each left-hand side, performing the contraction results in an inverse propagator that cancels with an existing one in the given integral
>
|
TensorReduce((16), step = 2);
|
Note the occurrence of a factor of the form on the right-hand side of the first equation. Such factors arise from the contraction of the metric in dimension where 4 is the value of the dimension currently set, as shown by .
Step 4 performs the contraction resulting in the system of equations for the involving only scalar Feynman integrals
>
|
TensorReduce((16), step = 4);
|
To see, for instance, the second equation in standard integral notation you can use
>
|
FromAbstractRepresentation((21)[2]);
|
Naturally, the reduction for more complicated integrals involves larger expressions, mainly in connection with the enlargement of the tensor basis. For example, the basis in the presence of two external momenta and and a product of three loop momentum with spacetime free indices is given by
>
|
TensorBasis([P__1, P__2], [~mu, ~nu, ~rho], symmetrize = false);
|
and has 6 elements instead of the 2 of the previous example