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.

PartSourceAuthors
Run as released and not bundled: PLD.jl, which pld_bridge.jl calls through getPLDPLD.jlFevola, Mizera and Telen
Translated: SOFIA.jl, from the diagram to the candidate singularitiesscr.m and scrj.m of SOFIACorreia, Giroux and Mizera
Translated: the odd-letter routines of SOFIA.jlEffortless.mMatijašić and Miczajka
Included unmodified under reference/The original sources; the PLD_database reference setThe same authors; Fevola, Mizera and Telen
Numerical check in pld_bridge.jlThe line-slicing method of arXiv:2311.16219; the solver HomotopyContinuation.jlFevola, 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.

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.

SOFIA.jl differs from the authors' SOFIA as follows.

The programs have these limits:

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

FunctionWhat 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.

CommandWhat it does
julia pld_bridge.jl SPEC.json OUT.jsonRuns getPLD on a graph specification and writes Landau Alphabet's output format
--method sym, --method numSymbolic or numerical elimination in PLD.jl
--save_output LOGRecords per-face results as they arrive
--load_output LOG --codim_start C --face_start IResumes 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_SRCEnvironment 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

Requirements

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.

ReferenceWhat 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: SOFIAThe method and the program that SOFIA.jl translates
A. Matijašić and J. Miczajka, EffortlessThe 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.01847The same algorithm
C. Fevola, S. Mizera and S. Telen, PLD.jl, Comput. Phys. Commun. 303 (2024) 109278, arXiv:2311.16219; companion paper arXiv:2311.14669The 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.08036With 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) 347The loop-by-loop Baikov construction, as in the SOFIA authors' code
P. Breiding and S. Timme, HomotopyContinuation.jl, ICMS 2018, arXiv:1711.10911The numerical solver of PLD.jl and of the numerical check

← back to the tools index