PLD and SOFIA (external)
PLD.jl and SOFIA are public programs that take a Feynman diagram and return polynomials in the kinematic invariants whose zeros are the places where its integral can be singular. PLD.jl is by Claudia Fevola, Sebastian Mizera and Simon Telen; SOFIA is by Miguel Correia, Mathieu Giroux and Sebastian Mizera. BootLoops runs both at the start of a calculation to fix the list of candidate symbol lettersthe arguments of the logarithms from which the answer is built; together they form the symbol alphabet, PLD.jl as released and SOFIA through SOFIA.jl, a Julia translation that runs without Mathematica.
Where it comes from
PLD.jl is the program of Fevola, Mizera and Telen for the principal Landau determinant (arXiv:2311.16219). SOFIA, by Correia, Giroux and Mizera (arXiv:2503.16601), is written in the Wolfram Language (Mathematica). Effortless, by Antonela Matijašić and Julian Miczajka, builds the odd letters that go with the square roots in an alphabet. BootLoops adds SOFIA.jl, a Julia translation of SOFIA and Effortless, and pld_bridge.jl, which runs PLD.jl on the input files of Landau Alphabet. Both were written by Claude, the bridge with PLD.jl's source open.
| Part | Source | Authors |
|---|---|---|
Run as released and not bundled: PLD.jl, which pld_bridge.jl calls through getPLD | PLD.jl | Fevola, Mizera and Telen |
| Translated: SOFIA.jl, from the diagram to the candidate singularities | scr.m and scrj.m of SOFIA | Correia, Giroux and Mizera |
| Translated: the odd-letter routines of SOFIA.jl | Effortless.m | Matijašić and Miczajka |
Included unmodified under reference/ | The original sources; the PLD_database reference set | The same authors; Fevola, Mizera and Telen |
Numerical check in pld_bridge.jl | The line-slicing method of arXiv:2311.16219; the solver HomotopyContinuation.jl | Fevola, Mizera and Telen; Breiding and Timme |
Please cite the authors' papers when you use these programs. SOFIA.jl and the bridge are not affiliated with or endorsed by the authors.
What it does
A Feynman integral depends analytically on its invariants (Mandelstam variables such as $s$ and $t$, and the squared masses) except on surfaces defined by polynomial equations, its Landau singularitiessolutions of the Landau equations: the kinematic configurations at which the integration contour is trapped between poles of the integrand. The one-loop bubble with internal masses $m_1$, $m_2$, for example, is singular where the Källén polynomial $\lambda=s^2+m_1^4+m_2^4-2sm_1^2-2sm_2^2-2m_1^2m_2^2$ vanishes.
A bootstrap calculation needs the complete list first, because the irreducible polynomials in it are the candidate letters of the answer. The two programs derive it from the graph alone by different methods, so agreement between them is strong evidence that it is right. BootLoops also checks Landau Alphabet against them.
PLD.jl computes the principal Landau determinant in two steps.
- Faces. It builds the Symanzik polynomials of the graph (polynomials in the Feynman parameters $x_i$) and works face by face through a polytope attached to them. Each face corresponds to one way a subset of the $x_i$ can scale to zero or infinity.
- Elimination. On each face it eliminates the $x_i$, symbolically (
method = :sym, through the computer-algebra system Oscar) or numerically (:num, through HomotopyContinuation.jl). The irreducible factors of the resulting discriminants are the candidates.
The bridge pld_bridge.jl reads a Landau Alphabet graph specification (a JSON file of edges, leg attachments and kinematics), calls PLD.jl's getPLD, and writes Landau Alphabet's output format. PLD.jl and Landau Alphabet can then be compared on identical input.
When PLD.jl or Oscar fails to load, or with --fallback, the bridge runs a lighter numerical check by the line-slicing method of Fevola, Mizera and Telen. On each face it solves the critical-point equations of the Lee-Pomeransky polynomial $U+F$ (the sum of the two Symanzik polynomials) along a seeded generic line through invariant space. The solutions are numerical witnesses of singular surfaces.
SOFIA proceeds as follows.
- Cut. It writes the diagram loop by loop in Baikov variablesa change of integration variables in which the propagator denominators themselves, plus a few extra scalar products, become the variables and sets the propagator variables to zero (the maximal cut).
- Eliminate. It eliminates the remaining variables from the resulting Gram determinants one at a time with resultants and discriminants, intersecting over elimination orders (the authors' FastFubini procedure).
- Subtopologies. It repeats this for every subtopology (every diagram obtained by contracting internal lines) and returns the union, factored and deduplicated.
- Odd letters. A separate routine builds the odd letters $(P-\sqrt Q)/(P+\sqrt Q)$ that go with each square root $\sqrt{Q}$ in the alphabet. Here $P^2-Q$ must be a multiple of a product of other letters (the Effortless construction).
SOFIA.jl differs from the authors' SOFIA as follows.
- Routes. In both programs the candidate set on the maximal cut depends on choices made during elimination, such as which lines carry the loop momenta.
routes=Nrepeats the elimination over up toNdeterministic variants and returns the union, a superset of any single route. - PLD.jl backend.
pld_singularities, the counterpart of the original'sSolver->momentumPLDoption, hands a diagram's Landau system to PLD.jl and returns the discriminants as polynomials in the kinematic ring. The caller passes the loaded module in, so PLD.jl and Oscar never become dependencies of the package. - Exact tests. Tests that the original does by random sampling (proportionality, perfect squares, letter independence) are exact.
- Left out. The diagram-drawing interface is not translated.
The programs have these limits:
- Either program returns candidates: the list can contain polynomials on which the integral is regular. It is not sorted into the first-entry and last-entry classes a bootstrap needs (the letters allowed in the first and the last slot of the symbol). Landau Alphabet does that sorting, and Leviathan tests candidates by a third method.
- PLD.jl sets no time limit on a face. The result is complete when the run finishes, and the run can be very heavy on multi-loop graphs with several masses.
- If
getPLDfails part-way, the bridge still writes the file, with"complete": falseand the error text, and exits with code 2. - PLD.jl names the invariants itself ($s,t$ for four legs, $s_{ij}$ for more), so comparing with Landau Alphabet's own output may need relabeling.
- The witnesses of the numerical check are interior pinches only (solutions with every Feynman parameter nonzero). They can include second-type surfaces (those not attached to a set of on-shell propagators), which a final alphabet drops; on the massless box this is $s+t$. They never appear for letters such as the box's $s$ and $t$. The check confirms letters but cannot certify completeness, and always writes
complete: false. - With
--check FILEthe bridge matches each witness against a candidate alphabet. It exits with code 2 if a witness matches no candidate, which means the candidate list is missing a letter. It also exits with code 2 if a face fails to solve. - On heavy multi-scale diagrams (a fully massive penta-box, several massive double-box configurations) an elimination in SOFIA.jl reaches an intermediate polynomial whose discriminant does not finish in practical time. The authors' SOFIA takes a different route and completes these cases.
- Two options make every SOFIA.jl run terminate:
time_budget(a time limit in seconds on each subtopology's eliminations) andmaxopterms(skip single resultants or discriminants whose inputs exceed a term count). Such runs miss deeper candidates on these graphs; for those, use the authors' SOFIA or PLD.jl. - On the authors' worked examples that complete, SOFIA.jl reproduces every recorded singularity in most cases, often with extra candidates, and misses one or two entries in two cases (
validation/REPORT.md).
Examples
Massless double box with SOFIA.jl. With the package set up (see Requirements), start Julia with julia --project=. in the package directory upgrades/SOFIA.jl/. The README example has seven internal lines (vertex pair, mass label, here all zero) and four external legs (vertex, mass label).
using SOFIA
import Nemo
# end to end: candidate Landau singularities of the massless double box
mz = BigInt(0)
dbox = Diagram([((1,2),mz),((2,3),mz),((3,6),mz),((6,5),mz),
((5,4),mz),((4,1),mz),((2,5),mz)],
[(1,mz),(3,mz),(4,mz),(6,mz)])
sing, ring = sofia_singularities(dbox) # -> {s12, s23, s12+s23} = {s, t, s+t}
sing contains s12, s23 and s12 + s23: the integral can be singular only at $s=0$, $t=0$ and $u=-s-t=0$. ring is a Nemo polynomial ring generated by the invariants SOFIA chose, which here include the cyclic Mandelstam invariants s12 and s23; massive legs and lines add squared-mass generators MM1, ... and mm1, .... The PLD reference set included with the package has the same entry: loadsingularities("reference/PLD_database/dbox_zero_zero.m") returns s, s + t, t with their ring and variable keys.
Masses and routes. Mass labels are symbols; lines with the same label share a mass. This block continues the README example.
# with masses: labels are symbols/indexed atoms; same label = same scale bub = Diagram([((1,2),:m1), ((1,2),:m2)], [(1,mz),(2,mz)]) sing, ring = sofia_singularities(bub) # contains Källén λ(s, mm1, mm2) # route-union mode: superset over elimination routes (see PORTING_NOTES) sing, ring = sofia_singularities(bub; routes=12) # optional PLD.jl backend (the original's Solver->momentumPLD): if PLD.jl is # installed, pass the module in # import PLD # sing, ring = pld_singularities(PLD, bub)
For the bubble sing contains the Källén polynomial $\lambda$ given above, with the squared masses appearing as the generators mm1 and mm2. With routes=12 the call returns the union over up to twelve elimination routes, which on larger diagrams can add entries. The commented lines run the same bubble through PLD.jl, so the two lists can be compared.
Odd letters. The odd-letter test from test/runtests.jl:
R, (s, mm1, mm2) = Nemo.polynomial_ring(Nemo.QQ, ["s", "mm1", "mm2"]) kallen = s^2 + mm1^2 + mm2^2 - 2s * mm1 - 2s * mm2 - 2mm1 * mm2 alphabet = [s, mm1, mm2, kallen] odd = find_odd_letters(kallen, alphabet) indep = independent_letters(odd, alphabet)
find_odd_letters returns three OddLetter records whose P fields are proportional to $s-m_1^2-m_2^2$, $s+m_1^2-m_2^2$ and $s-m_1^2+m_2^2$. Each stores Q (here $\lambda$) and the witness c, prod in $P^2=Q+c\cdot\mathrm{prod}$. independent_letters keeps the two whose logarithmic derivatives are independent given the even letters.
PLD.jl on a Landau Alphabet graph file. From the Landau Alphabet README, run in tools/landau-alphabet/ with PLD.jl in its own Julia 1.10 environment:
PLD_ENV=<your PLD julia env> julia pld_bridge.jl \
graph_specs/k4box3l.json k4box3l_alphabet_pld.json --method sym
k4box3l.json is the three-loop crossed massive box (six lines, one mass symbol m2, four massless legs), a heavy case; graph_specs/ also has box1l.json and sunrise2l.json for a first run. The output JSON carries alphabet (the distinct discriminant factors as strings), faces (one record per PLD.jl entry), complete, and a status block (under the key honesty) with any error text. first_entry and last_entry stay empty because PLD.jl does not classify letters.
The numerical check on the one-loop box. Without PLD.jl or Oscar, the bridge cross-checks a Landau Alphabet output numerically. From the README:
julia pld_bridge.jl graph_specs/box1l.json box1l_hc.json \
--fallback --check box1l_alphabet.json --seed 0
box1l_alphabet.json is Landau Alphabet's own output for the box (python landau_alphabet.py graph_specs/box1l.json --out box1l_alphabet.json). The leading face gives a witness on $s+t=0$, absent from that file's {s, t}, so the run exits with code 2 and a "CROSS-VALIDATION CATCH" message. With s + t added to the candidate file's alphabet list every witness matches and the exit code is 0.
Routines
| Function | What it returns |
|---|---|
Diagram(edges, nodes) | A diagram from internal lines [((u,v), mass), ...] and external legs [(vertex, mass), ...] |
sofia_singularities(d; routes, time_budget, maxopterms) | (polynomials, ring): the candidate Landau singularities of d with all subtopologies |
singularities_seed(d) | (polynomials, system) for one diagram, without subtopologies; system is the BaikovSystem, whose field ring holds the ring |
find_odd_letters(Q, alphabet), independent_letters(odd, evens) | The OddLetter records for the root Q, and those among them with independent logarithmic derivatives |
effortless_odd_letters(sing) | The odd letters of a singularity list; roots are the non-square entries and, by default, their pairwise products |
pld_singularities(PLD, d) | (polynomials, ring) for one diagram through PLD.jl |
loadsingularities(path) | The polynomials of a Wolfram-format PLD_database file, with their ring and variable keys |
The lower-level exports are listed at the top of src/SOFIA.jl, and the two symmetry routines in src/symmetry.jl.
The bridge is run in tools/landau-alphabet/, and the validation script in upgrades/SOFIA.jl/. The format of the graph specification is under "Input schema" in tools/landau-alphabet/README.md. The Landau Alphabet page describes the rest of that package.
| Command | What it does |
|---|---|
julia pld_bridge.jl SPEC.json OUT.json | Runs getPLD on a graph specification and writes Landau Alphabet's output format |
--method sym, --method num | Symbolic or numerical elimination in PLD.jl |
--save_output LOG | Records per-face results as they arrive |
--load_output LOG --codim_start C --face_start I | Resumes a long run from that face |
--fallback [--check CANDIDATES.json] [--seed N] [--tol X] | The numerical check: witnesses on a seeded generic line, matched against the candidates with tolerance X |
PLD_ENV, PLD_SRC | Environment variables: the Julia environment that holds PLD.jl, and a PLD source checkout for the load path |
julia --project=. validation/run_notebook_cases.jl [case indices...] | Replays the authors' worked examples |
The numerical check writes the same format, with method set to hc-fallback-numerical and any unmatched_witnesses under honesty. The similarly named pld_groebner_backend.py is Landau Alphabet's Gröbner-basis backend for hard faces, not part of PLD.jl; the Landau Alphabet page documents it.
Used on this site
- Kite: SOFIA's singularity analysis of the family with symbolic masses found the algebraic letter $s^2-12s+4$.
- Central-mass double box: SOFIA and PLD gave the Landau singularity analysis of the family, with the seven rational letters as faces of the principal $A$-determinant.
- Outer-mass double box: SOFIA's Landau singularity analysis of the diagram gave the rational letters and the candidate algebraic letters.
- gg → Zγ: the singularity analysis gave the letters in $(s,t)$ and the five cusps in $s$ of the $\Gamma_0(4)$ curve at $M=7/25$.
Requirements
- Runs on: SOFIA.jl needs Julia 1.10 or newer with the registered packages Nemo, AbstractAlgebra, Graphs and Combinatorics. It needs no Mathematica, and PLD.jl only for the optional backend.
- Install: in
upgrades/SOFIA.jl/runjulia --project=. -e 'using Pkg; Pkg.instantiate()'once. - Self-test:
julia --project=. -e 'using Pkg; Pkg.test()'runstest/runtests.jl. The suite tests the PLD.jl backend against a mock solver and adds a live run when PLD.jl is installed; otherwise it prints a skip message. - Optional, PLD.jl: PLD.jl comes from its authors at mathrepo.mis.mpg.de/PLD. It depends on Oscar and HomotopyContinuation.jl and, because of Oscar's GAP component, loads on Julia 1.10 but not on 1.11 or newer. Keep it in a separate Julia 1.10 environment named in
PLD_ENV. The bridge's header records Oscar 1.7.3 with HomotopyContinuation 2.20 as a working combination. - Optional, the bridge:
pld_bridge.jlneeds the Julia packages JSON and HomotopyContinuation. They are enough on their own for--fallback, which also runs on Julia 1.11 and newer. - Bridge self-test: in
tools/landau-alphabet/,python3 selftest.py --fullincludes the two runs of the last example and ends with a line beginningfull battery PASS. The bridge check is skipped with a message when Julia or HomotopyContinuation.jl is missing.
Source and references
SOFIA.jl is upgrades/SOFIA.jl/ in the BootLoops repository, and the bridge is tools/landau-alphabet/pld_bridge.jl there. In the SOFIA.jl directory, PATCHES.md and docs/PORTING_NOTES.md record its differences from the original, and LICENSE carries the copyright notices of SOFIA and Effortless.
| Reference | What it supplies |
|---|---|
| M. Correia, M. Giroux and S. Mizera, "SOFIA: Singularities of Feynman Integrals Automatized", Comput. Phys. Commun. 320 (2026) 109970, arXiv:2503.16601; code: SOFIA | The method and the program that SOFIA.jl translates |
| A. Matijašić and J. Miczajka, Effortless | The odd-letter program that SOFIA.jl translates |
| A. Matijašić, PhD thesis, LMU Munich (2024) | The algorithm of the odd-letter construction |
| J. Henn, A. Matijašić, J. Miczajka, T. Peraro, Y. Xu and Y. Zhang, Phys. Rev. Lett. 135 (2025) 031601, arXiv:2501.01847 | The same algorithm |
| C. Fevola, S. Mizera and S. Telen, PLD.jl, Comput. Phys. Commun. 303 (2024) 109278, arXiv:2311.16219; companion paper arXiv:2311.14669 | The principal Landau determinant, PLD.jl, the PLD_database reference set and the method of the numerical check |
| S. Mizera and S. Telen, "Landau discriminants", arXiv:2109.08036 | With arXiv:2311.16219, the line-slicing step of the numerical check |
| Frellesvig and Papadopoulos, JHEP 04 (2017) 083, arXiv:1701.07356; Baikov, Nucl. Instrum. Meth. A 389 (1997) 347 | The loop-by-loop Baikov construction, as in the SOFIA authors' code |
| P. Breiding and S. Timme, HomotopyContinuation.jl, ICMS 2018, arXiv:1711.10911 | The numerical solver of PLD.jl and of the numerical check |