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.
| Part | Source | Authors |
|---|---|---|
| pySecDec | github.com/gudrunhe/secdec, arXiv:1703.09692 | S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner, J. Schlenk, T. Zirke and later contributors |
The disteval evaluator of pySecDec | arXiv:2305.19768 | G. Heinrich, S. P. Jones, M. Kerner, V. Magerya, A. Olsson and J. Schlenk |
| FIESTA | gitlab.com/feynmanintegrals/fiesta, arXiv:2110.11660 | A. V. Smirnov, N. D. Shapurov and L. I. Vysotsky |
| The method of sector decomposition | hep-ph/0004013 | T. Binoth and G. Heinrich |
| New code around pySecDec: the staged driver and the arbitrary-precision evaluator | tools/longhand/, described under Longhand | BootLoops |
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.
- Input. The propagator list, the loop and external momenta, the kinematic substitution rules and a numerical point.
- Output. The Laurent series in $\varepsilon$ (the expansion in powers of $\varepsilon$, poles included), with a numerical coefficient and an error estimate at each order.
The programs have these limits:
- In the standard double-precision modes the result has about 8 to 9 digits, with no proven bound.
- Points in the physical region need the library compiled with contour deformation (a shift of the integration path into the complex plane), which pySecDec supports.
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:
- Route B. Longhand takes a library you have compiled with pySecDec (
loop_package, thenmake disteval) and runsdistevalon it three times, with two lattice sizes and then the median-lattice rule of Goda and L'Ecuyer. The runs go in chunks of sectors that resume after an interruption. Longhand then reports, order by order in $\varepsilon$, how many digits the two lattice constructions agree on, with self-checks in which a shifted value must fail the comparison. - Route A. Longhand takes $U$ and $F$ from pySecDec's
LoopIntegralFromPropagators, in the same normalization so that values compare digit for digit. It evaluates finite Euclidean integrals in arbitrary precision, past the double-precision ceiling. A value computed this way shares its $U$ and $F$ with pySecDec. - FIESTA. FIESTA is run as distributed, as a further cross-check, with no BootLoops code around it.
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/.
| Command | What it does |
|---|---|
pysecdec_point.py --stage A --disteval-dir D --work DIR | One of the three resumable disteval stages, for one compiled library at one point; B and C likewise |
pysecdec_point.py --stage compare | The per-order comparison of the stage results |
pysecdec_point.py --stage check | The acceptance check with its self-checks |
pysecdec_point.py --check-package | Compares a library with its recorded checksums |
pysecdec_point.py --emit-pins OUT | Writes the checksums of your own library; --pins selects them |
pysecdec_point.py --unpinned-package | Runs a library that does not match the checksums, and labels the results |
bench_se3l.py | A three-loop benchmark whose integrand is built through build_UF and whose target value is pySecDec's |
| Function | What 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
- pySecDec: install it with
pip install pySecDec. The evaluation records in Longhand were made with version 1.6.6. - FIESTA: the source is at gitlab.com/feynmanintegrals/fiesta.
- Documentation: installation and use of both programs are documented by the two projects themselves.
- Self-test: the BootLoops code around pySecDec is described with its self-tests on the Longhand page.
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.
| Reference | What it supplies |
|---|---|
| S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner, J. Schlenk and T. Zirke, pySecDec, arXiv:1703.09692; code: secdec | The program, with its front end LoopIntegralFromPropagators |
| S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner and J. Schlenk, arXiv:1811.11720 | The quasi-Monte Carlo lattice rules of pySecDec |
| G. Heinrich, S. P. Jones, M. Kerner, V. Magerya, A. Olsson and J. Schlenk, arXiv:2305.19768 | The disteval evaluator |
| A. V. Smirnov, N. D. Shapurov and L. I. Vysotsky, FIESTA, arXiv:2110.11660; code: fiesta | The second program |
| T. Binoth and G. Heinrich, hep-ph/0004013 | The method of sector decomposition |
| T. Goda and P. L'Ecuyer, arXiv:2201.09413 | The median-lattice rule of the third disteval run |