pySecDec and FIESTA (external)

pySecDec and FIESTA are public programs that compute a Feynman integral numerically by sector decompositiona recursive splitting of the integration region that untangles overlapping singularities, starting from its list of propagators and a kinematic point. pySecDec is by the SecDec collaboration (S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner, J. Schlenk, T. Zirke and later contributors), and FIESTA is by A. V. Smirnov and collaborators. BootLoops uses both unmodified, as a numerical check by a separate method; its own code around pySecDec is described under Longhand.

Where it comes from

pySecDec is the program of the SecDec collaboration, and FIESTA is the program of A. V. Smirnov, N. D. Shapurov and L. I. Vysotsky. The method of sector decomposition is due to T. Binoth and G. Heinrich. BootLoops adds no code inside pySecDec or FIESTA and does not redistribute either program. What BootLoops adds is part of Longhand: a driver that runs one compiled pySecDec library in checked, resumable stages, and an arbitrary-precision evaluator of the same parametric integral for finite Euclidean integrals.

PartSourceAuthors
pySecDecgithub.com/gudrunhe/secdec, arXiv:1703.09692S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner, J. Schlenk, T. Zirke and later contributors
The disteval evaluator of pySecDecarXiv:2305.19768G. Heinrich, S. P. Jones, M. Kerner, V. Magerya, A. Olsson and J. Schlenk
FIESTAgitlab.com/feynmanintegrals/fiesta, arXiv:2110.11660A. V. Smirnov, N. D. Shapurov and L. I. Vysotsky
The method of sector decompositionhep-ph/0004013T. Binoth and G. Heinrich
New code around pySecDec: the staged driver and the arbitrary-precision evaluatortools/longhand/, described under LonghandBootLoops

Please cite the authors' papers when you use either program. BootLoops is not affiliated with or endorsed by the authors of either.

What it does

Every Feynman integral can be rewritten in its Feynman-parameter formthe representation that trades the product of propagators for one integration variable per propagator, over a simplex, with two polynomials U and F built from the graph and the kinematics. For $N$ propagators, $L$ loops and dimension $d = 4 - 2\varepsilon$,

$$ I \;=\; \Gamma\!\left(N - \tfrac{L d}{2}\right) \int d^N x \;\delta\!\Big(1-\sum_i x_i\Big)\, \frac{U^{\,N-(L+1)d/2}}{F^{\,N-L d/2}} . $$

Sector decomposition splits the integration region until every divergence is an explicit power of one variable, subtracts the poles in $\varepsilon$, and integrates the rest numerically. pySecDec drives this from Python and compiles a C++ library for the integrand. Its disteval evaluator then integrates the library with quasi-Monte Carlo lattice rules (sums over a lattice of points, shifted at random to give an error estimate). FIESTA is a separate program, by other authors, in Mathematica and C.

The programs have these limits:

BootLoops keeps these programs as a check by a separate method. Sector decomposition uses no integration-by-parts reductionthe linear-algebra step that rewrites every integral of a family in terms of a small basis of master integrals, no differential equations and no auxiliary massa fictitious mass added to chosen propagators, the starting point of the method AMFlow uses. Agreement between a sector-decomposition value and an AMFlow value therefore confirms the number by two different methods. The programs are also a first test of whether an unfamiliar integral can be evaluated numerically. pySecDec's front end supplies the $U$ and $F$ polynomials to other tools: SubTropica's graph front end was checked against it on five graphs and agreed exactly.

What BootLoops adds around pySecDec is on the Longhand page. In short:

Examples

Build $U$ and $F$ from a propagator list. The one-loop box with three equal internal masses and one distinct mass M5, as Longhand's self-test sets it up. With pySecDec installed (see Requirements) and the repository's tools/ directory on sys.path:

from longhand.feynman import build_UF
props = ['k**2 - M5', '(k+p1)**2 - m2', '(k+p1+p2)**2 - m2', '(k-p4)**2 - m2']
rr = [('p1*p1', 0), ('p2*p2', 0), ('p3*p3', 0), ('p4*p4', 0),
      ('p1*p2', 's/2'), ('p3*p4', 's/2'),
      ('p2*p3', '(-s-t)/2'), ('p1*p4', '(-s-t)/2'),
      ('p1*p3', 't/2'), ('p2*p4', 't/2')]
U, F, xs, L, Nprop = build_UF(props, ['k'], ['p1', 'p2', 'p3', 'p4'], rr)

build_UF calls pySecDec's LoopIntegralFromPropagators and returns $U$ and $F$ as sympy polynomials in the Feynman parameters xs, with the loop count (L is 1) and the propagator count (Nprop is 4). Here $U$ is the sum of the four parameters, and $F$ still contains the symbols s, t, m2 and M5. Longhand's self-test substitutes $s=-1$, $t=-1/3$, $m^2=1$, $M_5^2=2$ and requires this $F$ to equal, term by term, the polynomial stored in its own box specification.

Check a compiled library before a long run. With a library compiled by pySecDec under PKG/disteval, from tools/longhand/disteval/:

python3 pysecdec_point.py --check-package --disteval-dir PKG/disteval
python3 pysecdec_point.py --disteval-dir PKG/disteval --stage A --workers 8 --work WORK

The first line compares the five files of the library with the checksums recorded for Longhand's worked example, and exits 0 on a match or 3 on a mismatch. For your own family, --emit-pins writes the checksums and --pins selects them. The second line runs the coarse first stage of the three-stage evaluation into WORK; the remaining stages, the comparison and the acceptance check are shown on the Longhand page.

Routines

The BootLoops code that calls pySecDec is part of Longhand. The driver pysecdec_point.py is in tools/longhand/disteval/ and the benchmark bench_se3l.py in tools/longhand/.

CommandWhat it does
pysecdec_point.py --stage A --disteval-dir D --work DIROne of the three resumable disteval stages, for one compiled library at one point; B and C likewise
pysecdec_point.py --stage compareThe per-order comparison of the stage results
pysecdec_point.py --stage checkThe acceptance check with its self-checks
pysecdec_point.py --check-packageCompares a library with its recorded checksums
pysecdec_point.py --emit-pins OUTWrites the checksums of your own library; --pins selects them
pysecdec_point.py --unpinned-packageRuns a library that does not match the checksums, and labels the results
bench_se3l.pyA three-loop benchmark whose integrand is built through build_UF and whose target value is pySecDec's
FunctionWhat it returns
longhand.feynman.build_UF(propagators, loop_momenta, external_momenta, replacement_rules)$U$, $F$, the Feynman parameters, the loop count and the propagator count, through LoopIntegralFromPropagators

Further options of the driver are described in tools/longhand/DISTEVAL.md. FIESTA is called by hand as its own documentation describes; nothing in the toolkit wraps it.

Requirements

Source and references

The BootLoops code around pySecDec is tools/longhand/ in the BootLoops repository, released under the MIT license. The licenses of the two programs are listed on the credits page.

ReferenceWhat it supplies
S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner, J. Schlenk and T. Zirke, pySecDec, arXiv:1703.09692; code: secdecThe program, with its front end LoopIntegralFromPropagators
S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner and J. Schlenk, arXiv:1811.11720The quasi-Monte Carlo lattice rules of pySecDec
G. Heinrich, S. P. Jones, M. Kerner, V. Magerya, A. Olsson and J. Schlenk, arXiv:2305.19768The disteval evaluator
A. V. Smirnov, N. D. Shapurov and L. I. Vysotsky, FIESTA, arXiv:2110.11660; code: fiestaThe second program
T. Binoth and G. Heinrich, hep-ph/0004013The method of sector decomposition
T. Goda and P. L'Ecuyer, arXiv:2201.09413The median-lattice rule of the third disteval run

← back to the tools index