// Research · Feynman integrals

Feynman integrals,
reduced exactly.

Integration-by-parts reduction to master integrals by solving modulo primes and reconstructing the exact result: measured against FIRE on its own double box, and against Forcer on FORM's four-loop checks.

// A result · 8 November 2026 · PQCF 1.4.0

Reducing Feynman integrals,
measured against FIRE.

In a particle-physics calculation, the largest step is often not the calculation but simplifying its result. The integrals it produces are reduced to a small set of master integrals, using integration-by-parts identities: systems of tens of thousands to millions of linear equations whose coefficients are rational functions of the dimension and the kinematics. Physicists often spend more time on this reduction than on the rest of the calculation. Dedicated programs do it, among them FIRE and Kira.

How PQCF does it. PQCF never solves the system symbolically. It solves it with plain numbers, modulo large primes, at sample points, and reconstructs the exact rational coefficients from those values. Every sample is independent, so the work spreads over cores or machines and gives the same answer on any number of them.

The benchmark: FIRE's own example. The two-loop massless planar double box, from FIRE's examples, with 7 propagators and 2 numerators, in the dimension d and the invariants s and t. We reduce FIRE's target and a harder one with an extra numerator. Both programs give the same answer. We checked it at a random point modulo a large prime, master by master: FIRE's 12 masters are PQCF's 8, up to the family's symmetries.

Where we stand: one core each, back to back on the same core:

  • FIRE's target, I(1,1,1,1,1,1,1,−1,−1): PQCF 1.21 seconds, FIRE 7.99. PQCF is 6.6 times faster.
  • The harder target, I(1,1,1,1,1,1,1,−2,−1): PQCF 3.73 seconds, FIRE 11.99. PQCF is 3.2 times faster.
Dot plot on a log time axis, one core. FIRE's target: FIRE 6.5.2 7.99 seconds, PQCF 3.95 seconds on 7 November and 1.21 on 8 November. The harder target: FIRE 11.99 seconds, PQCF 32.2 seconds on 7 November and 3.73 on 8 November

How we got there. It didn't start well. Our first attempt built one large system of equations, the textbook method, and a single elimination of it took 56 seconds, while FIRE needed 16 for the whole reduction. Each step below was measured, and each kept the answer exact:

  • Only the equations the target needs. One numerical elimination, done once, records which equations the target depends on; every later sample solves only those. On the double box: 54,549 of 198,160 equations, and 0.19 seconds per sample instead of 56.
  • The family's symmetries. Integrals that are equal by a symmetry of the diagram are recognised and counted once. The target then reduces to the 8 masters the double box is known to have.
  • Shared samples. One elimination gives the coefficient of every master at once, so each sample point is computed once and reused for all of them.
  • The equations chosen automatically, starting small and growing until the target reduces completely: 7,300 equations instead of 198,160.
  • Denominator guessing, as the dedicated programs do. On a few one-variable slices, PQCF reads which simple factors, such as d − 4 or s + t, divide each coefficient's denominator. It then reconstructs numerator times denominator as a polynomial, which needs far fewer samples. A wrong guess fails a final check and falls back to the general method. On the harder target, 32 seconds became 9.
  • A learned elimination. The sequence of steps of an elimination is the same at every sample point, so it is recorded once and replayed. Measuring the replay found the real bottleneck: modular inversion. It was done by exponentiation, about 126 multiplications, each a slow 128-bit operation on our ARM processor. The extended Euclidean algorithm replaced it. A sample now costs 2.9 milliseconds instead of 31.

The results are written the way physicists write them. Every coefficient is simplified and checked against the original. For example, (−255 + 323/2 d − 51/2 d²) / (16s − 8ds + d²s) becomes −(17/2)(3d − 10)(d − 3) / (s (d − 4)²). FORM's factorisation confirms that what remains doesn't factor further.

What the comparison is, and isn't.

  • FIRE ran single-threaded with its open simplifier, FLINT. We built version 6.5.2 from source for our ARM machine, which needed two small build fixes.
  • Kira wasn't compared. It requires the Fermat program, which runs only on x86, and whose licence forbids use in a for-profit business without its author's written permission.
  • Sizes and timings. The double box is small by research standards: larger families, and samples spread across machines, come next. Both programs ran on a shared machine, where times vary by up to about a third.
  • FORM, solving the same smaller systems (a one-loop box and a two-loop family) symbolically, is now about as fast as PQCF on them. The gains show on the larger systems.

Also tried: a physics-informed neural network, learning the masters' values from their differential equations, which PQCF now derives exactly from the same identities. It reached an accuracy of 1 in 10,000 after 52 seconds of training on our GPU. A classical solver reaches 1 in 1013 in 19 milliseconds. A negative result for evaluating integrals, written down as one.

Released in PQCF 1.4.0 (8 November), as part of the library: a family of integrals is described as data, and one call reduces any number of targets with automatically chosen equations, or derives the masters' differential equations (release notes).

The method, every measurement and the code: decision record R1, comparison/fire (FIRE's build and the cross-check) and comparison/form (the reductions and the comparison with FORM).

How to reproduce the results: a step-by-step page: FIRE built at the version we measured, the suite run on one core, every answer compared exactly, in about 90 seconds.

// A result · 9 November 2026 · PQCF

Four-loop integrals from QCD,
checked against FORM's Forcer.

FORM's own test suite checks Forcer, its program for four-loop massless propagator integrals, on fixed inputs with exact expected answers (forcer.frm). These integrals are the core of the five-loop β-function of QCD (Herzog, Ruijl, Ueda, Vermaseren, Vogt, arXiv:1701.01404), computed with FORM and Forcer (Ruijl, Ueda, Vermaseren, arXiv:1704.06650). We reduced the same integrals with PQCF.

What was compared.

  • A three-loop integral with two numerators, and the two-loop kite with two lines raised to the power 1 + ε.
  • The three four-loop non-planar top topologies, with 11 lines and 14 invariants each: all lines once, and the 14 variants with one squared line or one numerator.

The answers are exact. PQCF reduces each integral to master integrals. Their values are published (Lee, Smirnov, Smirnov, arXiv:1108.0732; Baikov, Chetyrkin, arXiv:1004.1153), and we use them as Forcer ships them. Forcer takes them from the same papers.

  • Against Forcer's results: all 10 integrals agree exactly, compared as expansions in ε to between 3 and 7 orders.
  • Against FORM's own checks: all 5 expected results are reproduced exactly in the MS-bar scheme, every coefficient from ε−4 to ε0, including ζ3 to ζ7.

The speed: Forcer is much faster on four loops. Forcer solves its reduction rules once, in advance, for each of its 437 topologies. PQCF builds and solves a system of equations for every problem.

FORM's checkFORM + Forcer, 1 corePQCF, 16 cores
three-loop example0.51 s0.04 s
four loops, three topologies10.3 s175 s (918 s in our first run)
four loops, two topologies5.2 s132 s (767 s in our first run)

What we changed since the first run, keeping every answer exact, cut PQCF's time on four loops by a factor of 5 to 6. Forcer is now 17 to 25 times faster there, down from 75 to 150; on the three-loop example PQCF is 13 times faster:

  • Equations chosen sector by sector. Only the sectors that need more equations get them: 97,949 equations instead of 374,416 in one case.
  • One reconstruction for a sum. Each check needs only the sum of its integrals, so PQCF reconstructs that sum directly, not every integral's coefficients one by one.
  • Only the parts that matter carried along. A four-loop system carried 19,841 right-hand sides, of which 21 matter; the others are now dropped first.
  • One check instead of dozens. Whether the chosen equations suffice is now tested with one solve on a random combination of the integrals, not one per integral: 38 seconds became 5.

What PQCF gained from it: integral families with lines of power n + ε, numerators given as scalar products, and finding a four-loop family's symmetries in 0.7 seconds instead of 75.

PQCF's results themselves are published, not only the comparison: every reduction with its exact coefficients in d, every expansion in ε and every MS-bar result, in comparison/forcer/results/symbolic.

Every number, the method and the code: comparison/forcer. FORM 5: arXiv:2601.19982.

How to reproduce the results: a step-by-step page: two images, one script, about 7 minutes on 8 cores; every check must say equal, and PQCF's published results must come out unchanged.