PMflow

PMflow computes the boundary valuesthe starting values of the differential equation that the engine solves that BootLoops' build of AMFlow.cpp does not reach for a class of gravitational scattering integrals. It drives that build, called the engine on this page (see AMFlow), which implements the auxiliary-mass-flow methodsome propagators get an artificial mass, and a differential equation in that mass carries the integrals down to zero mass of Xiao Liu, Yan-Qing Ma and Chen-Yu Wang, and solves a linear self-consistency problem at high precision. Auxiliary mass flow for linear propagators (linear in the loop momentum) is due to Zhi-Feng Liu and Yan-Qing Ma (arXiv:2201.11636) and is available in the Mathematica AMFlow, with which PMflow has not been compared.

What it does

Calculations of two black holes scattering, expanded order by order in Newton's constant (the post-Minkowskian expansion), produce families of Feynman integrals. Every integral in a family reduces to a finite set of master integralsa basis for the family: once these are known numerically, every other integral in the family follows by linear algebra. The engine evaluates the masters by giving some propagators an artificial mass $\eta$ and following a differential equation from very large $\eta$, where the integrals are simple, down to $\eta=0$. The values at large $\eta$ come from simpler "boundary families", found by the same idea applied recursively.

In the families PMflow is built for, the two heavy bodies appear as linearized propagators $1/(2k\cdot u_i)$ placed on shell (cut). A cut line cannot carry the artificial mass, and sending $\eta$ to infinity on the other lines reproduces the original family exactly. In BootLoops' engine the recursion then descends through identical copies and never reaches a simple one: it has a fixed point.

The Mathematica AMFlow treats linear propagators by the method of Z.-F. Liu and Y.-Q. Ma, which adds an auxiliary quadratic term to each linear propagator. PMflow leaves the linear propagators as they are and turns the fixed point into the boundary condition. The flow is linear in its boundary data, so one run per unit boundary vector gives a response matrix $A(\varepsilon)$ at each value of the dimensional regulator $\varepsilon$ on a grid. A self-consistent boundary vector $M$ must satisfy $(A(\varepsilon)-I)\,M=0$.

One flow leaves many directions undetermined. PMflow stacks the constraints of several flows, with $\eta$ on different subsets of propagators, into one overdetermined system. The remaining directions are set by closed-form values at chosen corner sectors of the basis (a sector is a set of propagators), called anchors in the solver. The default anchor is the cut tadpole $J=-(i/8)\,\pi^{-3/2}\,\Gamma(\varepsilon-\tfrac12)^3$, named J63 in the solver.

The calculation has four steps:

AMFlow lets a user supply boundary integrals by hand, and AMFlow.cpp carries that feature as explicit_boundary. discover and inject automate the hand procedure.

The companion gf_eps0_ratios.py reads the per-$\varepsilon$ master values that such a run writes to its log. All masters of one sector share a large factor that jumps erratically between $\varepsilon$ nodes, so a fit to the raw values fails. In ratios within a sector the factor cancels exactly.

The script extrapolates each ratio to $\varepsilon=0$ and keeps only the digits on which the full grid and an inner subset agree. It then tries to identify the limit as a rational number with PSLQan integer-relation algorithm: given a few high-precision numbers it finds small integers combining them to zero, or reports that none exist below a size bound (integers up to $10^{19}$), and flags an identification WEAK if fewer than 90 digits agree.

PMflow has these limits:

The package was validated on a fourth-order post-Minkowskian cut family with 15 propagators and 43 master integrals, at two kinematic points.

Examples

Run the self-test suite. With the package set up (see Requirements), run from the package directory tools/pmflow/:

python3 selftest.py

Each check prints [PASS] or [FAIL], and a good run ends with a line beginning OVERALL: PASS. The suite recovers the ratios $-2/5$ and $22/7$ built into a synthetic log, and solves a synthetic two-master system whose answer is $J$ and $2J$. Two checks that read the engine source print [SKIP] when that source, g++ or the FLINT headers are absent.

Extract rational $\varepsilon^0$ ratios from a dumped $\varepsilon$-grid log. The call below is the one the self-test makes. --rows 0-2 selects masters 0 through 2, with master 0 as the denominator:

python3 gf_eps0_ratios.py --log synthetic_eps_grid.log --rows 0-2 --n-eps 8 --dps 120 --out table.json

For each ratio the script prints the identified fraction and the number of digits it matches, or NOT identified. table.json holds one entry per ratio with numerator p, denominator q and verified_digits, or the decimal value when no rational was found. The exit status is nonzero if any identification is weak.

Run the six subcommands in order, from the repository root. Upper-case names stand for your own inputs: FAMILY.json, CHAIN.json and PARENT.json are engine input files, and CSV, SPEC and fp_A.json are described under Routines:

python tools/pmflow/pmflow.py detect   --json FAMILY.json --etac CSV
python tools/pmflow/pmflow.py discover --json CHAIN.json --keys-out keys.json --etac CSV
python tools/pmflow/pmflow.py respond  --json CHAIN.json --keys keys.json --dir PROBEDIR --par N
python tools/pmflow/pmflow.py map      --keys keys.json --families ending_families.json \
    --fpA fp_A.json --out circular_map.json
python tools/pmflow/pmflow.py solve    --fpA fp_A.json --probes PROBEDIR \
    --cmap circular_map.json --anchors SPEC --out fp_boundary.json
python tools/pmflow/pmflow.py inject   --parent PARENT.json --table fp_boundary.json \
    --depth 1 --out OUT.json

respond fills PROBEDIR with one log per key. solve prints the residual summary and writes fp_boundary.json, a JSON table of boundary values per $\varepsilon$. inject leaves the engine's result for the parent family in OUT.json.

Routines

CommandWhat it does
pmflow.py detectReports FIXED_POINT on the engine's GRAVITYFLOW_FIXEDPOINT stop or on identical trace levels, else DESCENDING; --work-dir DIR sets the run directory
pmflow.py discoverWrites the missing keys to keys.json; --max-iter, --force-depth, --cut-probe and --timeout adjust the loop
pmflow.py respondRuns the unit-value probes, --par N at a time, and writes per-$\varepsilon$ master values to the probe logs
pmflow.py mapMatches each key to a master of the basis family and writes circular_map.json; --parent-json CHAIN.json names the parent propagators
pmflow.py solveWrites the boundary table; --n-eps N is the grid length of the probe logs, --extra-zero KEY ... adds exact zeros
pmflow.py injectFills explicit_boundary in the parent input and runs the engine with AMFLOW_FORCE_ENDING_DEPTH
gf_solve.pyThe solver behind solve, callable directly with the options of solve
gf_eps0_ratios.pyRatio extrapolation and rational identification; --n-eps is the number of $\varepsilon$ nodes, --dps the working precision
selftest.pyThe self-test suite

--etac has one comma-separated entry per propagator and marks the lines that carry the artificial mass. Pass --etac '' to let the engine choose, which is needed when a graviton line is cut. Do not omit it: the built-in default fits only a 15-propagator family, and the engine aborts on any other.

--anchors takes a list "SECTOR:FORM,...", where bit $i$ of the sector number marks propagator slot $i$ and J63 is the built-in form. The default, "63:J63,111:J63", fits only the 15-propagator reference family. On any other family solve refuses with a message until a matching list is supplied.

map prints the keys it cannot match and leaves them out, unless --foreign-as-j63 assigns them the tadpole value. fp_A.json is the response matrix that an engine run with AMFLOW_FIXEDPOINT_PROBE=1 writes.

FunctionWhat it returns
gf_solve.solve(...)The same solve from Python: 0 when every redundant equation is consistent, 1 otherwise
gf_solve.J63(eps)The closed-form cut tadpole at eps
gf_solve.ANCHOR_FORMSThe closed forms that --anchors accepts, at present J63 only

Every option of a subcommand is listed by its --help.

Requirements

Source and references

The code is tools/pmflow/ in the BootLoops repository. DESIGN.md there describes the algorithm and GUIDE.md records the validation.

ReferenceWhat it supplies
X. Liu, Y.-Q. Ma and C.-Y. Wang, Phys. Lett. B 779 (2018) 353, arXiv:1711.09572The auxiliary-mass-flow method
X. Liu and Y.-Q. Ma, AMFlow, arXiv:2201.11669; code: AMFlowThe program: its boundary recursion and the option to supply boundary integrals by hand
Z.-F. Liu and Y.-Q. Ma, Phys. Rev. D 105 (2022) 074003, arXiv:2201.11636Auxiliary mass flow for linear propagators, available in the Mathematica AMFlow
The AMFlow.cpp contributors, AMFlow.cppThe C++ engine that PMflow drives, through BootLoops' fork
M. Driesse, G. U. Jakobsen, G. Mogull, C. Nega, J. Plefka, B. Sauer, J. Usovitsch, Phys. Rev. Lett. 137 (2026) 081402, arXiv:2601.16256An example of the class of integrals PMflow is built for

← back to the tools index