Normalization of integral_without_prefactor

[vsht]

Hi,

I have a very naive question regarding integral_without_prefactor when loading the compiled library, like

integral_without_prefactor, prefactor, integral_with_prefactor = li(verbose = True,
real_parameters = num_params_real,
complex_parameters = num_params_complex)

I was checking the analytic result for a C0 function at a threshold, say C0(Mx^2,Mx^2,4 Mx^2,0,Mx^2,0). To that
aim I consider

#!/usr/bin/env python3
from pySecDec import sum_package, loop_package, loop_regions, LoopIntegralFromPropagators
import pySecDec as psd

li = LoopIntegralFromPropagators(
['(l + p1)**2', '(l - p2)**2', 'l**2 - Mx**2'],
loop_momenta = ['l'],
powerlist = [1, 1, 1],
dimensionality = '4 - 2*eps',
Feynman_parameters = 'x',
replacement_rules = [('Mx**2','Mx**2'), ('Mx**2','Mx**2'), ('Mx**2','Mx**2'), ('p1**2','Mx**2'), ('p1*p2','Mx**2'), ('p2**2','Mx**2')],
regulators = ['eps']
)

import os,shutil
if os.path.isdir('loopint'):
    if input('The directory loopint already exists, do you want to overwrite it (y/n)? ') in ['y','Y','j']:
        shutil.rmtree('loopint')
    else:
        exit(1)

loop_package(
name = 'loopint',
loop_integral = li,
requested_orders = [0],
real_parameters = ['Mx'],
contour_deformation = True,
additional_prefactor = '(1)',
decomposition_method = 'geometric'
)

which is generated automatically via PSDCreatePythonScripts

My analytic result is calculated in the "FeynCalc" / "old Denner" convention, where the prefactor is just $1/(i \pi^2)$

1/(I Pi^2) FAD[{l, Mx}, {l + p1, 0}, {l - p2, 0}]

So I thought that if integral_without_prefactor really gives the integral without any prefactors, then
I could just take that, divide it by $1/(i \pi^2)$ and compare to my analytic result.

However, the results surprisingly agree without the division by $1/(i \pi^2)$!

This makes me suspect that integral_without_prefactor actually still means something like
$1/(i \pi^2)$ per loop. Is this correct, or is it just me messing up the normalization somewhere?
I checked the manual but could not really find the precise meaning of integral_without_prefactor
explained there.

Cheers,
Vladyslav

[gudrunhe]

Hi Vladyslav,

thanks for the comment, indeed the factor of 1/(i\pi^2) per loop is always included, we consider it as part of the integration measure.
In the documentation this is explained in section 6.6 (FAQs).

Cheers, Gudrun

[vsht]

Hi Gudrun,

thanks a lot for the explanation.

So just to be sure that I got it right:

• integral_without_prefactor is what one gets using the standard UF-formula (sec 6.6), while integral_with_prefactor effectively returns integral_with_prefactor times additional_prefactor.

• but then prefactor in

integral_without_prefactor, prefactor, integral_with_prefactor = li(verbose = True,
real_parameters = num_params_real,
complex_parameters = num_params_complex)

will be always 1 for libraries generated via loop_package while for libraries generated via make_package it
will return the value of the prefactor argument in the constructor of make_package.

Is this correct?

Cheers,
Vladyslav

[spj101]

Hi Vladyslav,

Thank you for this good question. We have added a section on this topic to the faq of our internal repo, which will eventually become public. I append the new section below, I hope it makes sense and I am happy to hear your comments.

Best,
Stephen

What exactly is returned when calling :func:IntegralLibrary <pySecDec.integral_interface.IntegralLibrary> in the python interface?

In order to compute an integral in the python interface, first an :func:IntegralLibrary <pySecDec.integral_interface.IntegralLibrary> needs to be instantiated and then called.

.. code::

myintegral = IntegralLibrary('myintegral/myintegral_pylink.so')
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = myintegral()

The call to myintegral will return 3 strings.
The precise definition each string depends on how the integral library was initially generated.
In the above code, str_prefactor returns 1 in almost all cases.
The one exception is if the integral library was generated by a call to the code_writer version of make_package.
If you are using any of the primarily user facing functions (i.e. those we demonstrate in the examples/ folder), then we would advise just using str_integral_with_prefactor and not utilising str_integral_without_prefactor or str_prefactor.

Below we document the various ways an integral library can be generated and the precise content of the prefactor string.
Note that any internally generated prefactors, for example from Feynman parametrisation, are always included in the integral and not str_prefactor.

:func:pySecDec.sum_package <pySecDec.code_writer.sum_package> (:func:pySecDec.code_writer.sum_package)

The prefactor may be specified in the ``package_generator`` passed to :func:`pySecDec.sum_package <pySecDec.code_writer.sum_package>`, the two options are:

* ``MakePackage(prefactor='x', ...)`` :  ``x`` is included in ``str_integral_without_prefactor`` and ``str_prefactor = 1``

* ``LoopPackage(additional_prefactor='x', ...)`` : ``x`` is included in ``str_integral_without_prefactor`` and ``str_prefactor = 1``

:func:pySecDec.make_package

This function is a thin wrapper around :func:`pySecDec.code_writer.sum_package`

* ``make_package(prefactor='x', ...)`` : ``x`` is included in ``str_integral_without_prefactor`` and ``str_prefactor = 1``

:func:pySecDec.loop_package <pySecDec.loop_integral.loop_package> (:func:pySecDec.loop_integral.loop_package)

This function is a thin wrapper around :func:`pySecDec.make_package`

* ``loop_package(additional_prefactor='x', ...)`` : ``x`` is included in ``str_integral_without_prefactor`` and ``str_prefactor = 1``

:func:pySecDec.code_writer.make_package

This function is primarily used internally to handle the generation of sector decomposed integral libraries.

* ``make_package(prefactor='x', ...)`` : ``x`` is not included in ``str_integral_without_prefactor`` and ``str_prefactor = x``, ``str_integral_with_prefactor = x * str_integral_without_prefactor``.

[vsht]

Many thanks for the clarifications!