FunKit: A computer algebra toolkit for functional approaches

This paper introduces FunKit, a versatile Mathematica package designed to derive and trace functional equations from arbitrary master equations across various field theories, while offering efficient tensor tracing via FORM and code generation capabilities for C++, Julia, and Fortran.

The Gist

Imagine you are trying to solve a massive, impossible puzzle. This puzzle represents the fundamental laws of the universe (Quantum Field Theory). The pieces are equations that describe how particles interact, but these equations are so complex that they look like tangled spaghetti. If you try to solve them by hand, you will get lost in the knots before you even start.

FunKit is a new, super-smart robot assistant designed specifically to untangle this spaghetti. It is a software toolkit written in a language called Mathematica that helps physicists derive, simplify, and prepare these complex equations for computers to solve.

Here is how FunKit works, broken down into simple steps:

1. The Master Blueprint (The "Master Equation")

In physics, there is a "Master Equation" (like the Wetterich equation or Dyson-Schwinger equations) that acts as the ultimate blueprint. It contains the rules for how the universe works, but it's written in a very abstract way.

• The Problem: To find out how specific particles (like gluons or electrons) behave, physicists need to take this blueprint and "slice" it repeatedly (mathematically speaking, taking derivatives) to get specific instructions for those particles. Doing this by hand is like trying to cut a diamond with a butter knife—it's slow, messy, and prone to breaking the diamond.
• The FunKit Solution: FunKit acts like a laser-guided saw. You tell it, "Here is the blueprint, and here are the specific particles I want to study." FunKit instantly performs the slicing, generating the exact mathematical instructions needed without getting tired or making a mistake.

2. The "Super-Index" Trick

One of the hardest parts of these equations is keeping track of signs, especially when dealing with particles that behave like fermions (which act a bit like magnets that flip when you swap them).

• The Analogy: Imagine a dance floor where every time two dancers swap places, the music changes from major to minor. If you swap them back, it changes again. If you have 100 dancers, keeping track of the music is impossible.
• The FunKit Solution: FunKit uses a "Super-Index" system. Instead of writing out every single swap, it uses a special shorthand that automatically knows when to flip the sign. It's like having a dance instructor who whispers the correct music change to the band instantly, so the dancers never have to think about it.

3. The "Pruning" Garden (Truncation)

When FunKit slices the blueprint, it often produces a garden of thousands of possible diagrams (paths particles could take). Many of these paths are dead ends or irrelevant to the specific question being asked.

• The Analogy: Imagine you are looking for a specific type of flower in a forest. The forest is full of trees, rocks, and other plants. You don't want to analyze every single leaf; you just want the specific flower.
• The FunKit Solution: FunKit has a "pruning" tool. You tell it, "Only keep the paths that involve these specific particles." It instantly cuts away the rest of the forest, leaving you with a clean, manageable set of diagrams that actually matter.

4. The "Translator" (Code Generation)

Once FunKit has the clean, simplified equations, they are still written in a language only Mathematica understands. To actually calculate the answers (like how heavy a particle is), physicists need to run these equations on supercomputers using languages like C++, Julia, or Fortran.

• The Analogy: FunKit is like a universal translator. It takes the complex, abstract "Mathematica" recipe and instantly rewrites it into a "C++" or "Fortran" cookbook that a high-speed computer chef can read and cook with.
• The Bonus: FunKit doesn't just translate; it optimizes. It rearranges the ingredients to make the cooking process as fast as possible, ensuring the computer doesn't waste time or memory.

5. Why is this better than the old tools?

The paper compares FunKit to two other popular tools (DoFun and QMeS).

• Flexibility: While the other tools are like specialized screwdrivers that only work on specific types of screws, FunKit is a Swiss Army knife. It can handle any type of master equation, not just the standard ones.
• Speed: When the puzzles get huge (involving thousands of diagrams), FunKit is significantly faster. It works like a team of workers in parallel, tackling different parts of the puzzle at the same time, whereas older tools often work one step at a time.
• Completeness: FunKit handles the entire journey. It starts with the theory, derives the equations, simplifies them, and hands you the final code ready to run. Other tools often stop halfway, leaving the user to do the rest manually.

In Summary

FunKit is a "pipeline" for theoretical physics. It takes a vague, abstract theory, chops it into precise mathematical pieces, cleans up the mess, and hands you a polished, high-speed computer program ready to simulate the universe. It allows physicists to stop wrestling with algebra and start focusing on the physics itself.

Technical Summary

Technical Summary: FunKit – A Computer Algebra Toolkit for Functional Approaches

Problem Statement

Functional approaches in Quantum Field Theory (QFT), such as the Functional Renormalisation Group (fRG) and Dyson–Schwinger equations (DSE), are essential for calculating non-perturbative aspects of physical systems ranging from condensed matter to QCD. These methods require deriving closed expressions for vertices by taking functional derivatives of master equations (e.g., the Wetterich equation). However, this process generates an infinite tower of functional equations that must be truncated to maintain a finite number of loops while preserving relevant physics.

As physical systems require sophisticated truncations for qualitative reliability, the resulting diagrammatic expressions grow rapidly in size, making manual calculation impossible even for modest truncations in theories like Yang–Mills. Existing software solutions face specific limitations:

• DoFun and QMeS are powerful but restricted to specific master equations and lack support for arbitrary user-defined equations.
• FormTracer and TensorBases provide tools for tracing tensor structures but do not offer a complete pipeline from theory specification to numerical code.
• There is a lack of software that seamlessly integrates the derivation of arbitrary functional equations, the handling of complex Grassmann signs, multi-loop momentum routing, and the generation of highly optimized code for numerical solvers (C++, Julia, Fortran).

Methodology

FunKit is a Mathematica package designed to provide a complete pipeline for functional methods, from theory specification to executable code. Its methodology is built on a modular architecture and a robust internal vocabulary.

1. Superindex Notation and Vocabulary

To handle indices reliably, particularly for fermionic fields, FunKit employs a superindex notation (following conventions in [7, 29]). A single superfield $\Phi_a$ encapsulates field type, momentum, and group indices.

• Grassmann Signs: The package uses a field metric $\gamma_{ab}$ and a sign object $(-1)^{ab}$ to encode anti-commutation relations automatically, ensuring correct sign handling for fermionic permutations.
• Expression Structure: Functional equations are represented using FTerm (non-commutative products) and FEx (sums of terms). This structure allows for the precise ordering of factors and the handling of non-commutative objects like Grassmann fields.
• Extensibility: The vocabulary is fully user-extensible. Users can define new objects, custom indexed objects, and specific functional derivative rules via FAddObject and FAddFDRule.

2. Derivation Pipeline

The workflow, illustrated in Figure 1 of the paper, proceeds through distinct stages:

• Theory Specification: Users define field spaces (commuting and Grassmann fields), truncations (which correlation functions are retained), and interaction bases.
• Functional Derivatives: The FTakeDerivatives function applies derivatives to master equations. It utilizes a product rule expansion and automatically resolves derivative operators (FDOp).
• Truncation: FTruncate filters diagrams based on the user-defined truncation table, discarding terms involving vertices or fields not included in the setup. It employs an "early pruning" strategy to prevent combinatorial explosion.
• Routing: FRoute assigns explicit momenta and group indices to diagrams, identifying loop momenta and grouping terms by loop order. It distinguishes between purely fermionic loops (relevant for finite-temperature Matsubara sums) and bosonic loops.
• Diagrammatic Rules & Tracing: FunKit interfaces with TensorBases to automatically generate Feynman rules from tensor bases. It then uses FormTracer (which delegates to the FORM language) to trace tensor structures and perform group algebra contractions efficiently.
• Code Generation: The final step involves parametrizing symbolic dressings and exporting the traced expressions to C++, Julia, or Fortran.

3. Optimization and Parallelization

FunKit incorporates several optimization strategies:

• Parallelization: Tasks such as diagram simplification, derivative resolution, and FORM tracing are parallelized across available CPU cores.
• Code Optimization: The code generation pipeline includes common subexpression elimination (CSE), power normalization, algebraic factoring, and FMA (fused multiply-add) restructuring. It targets a register budget suitable for both CPU and GPU solvers.
• Caching: Tracing results are cached to avoid redundant computations.

Key Contributions

The paper presents FunKit as a comprehensive solution with the following specific contributions:

1. Arbitrary Master Equations: Unlike DoFun or QMeS, FunKit supports arbitrary user-defined master equations, including modified Slavnov–Taylor identities (mSTIs), flowing reparametrisations, and nPI equations.
2. Full Pipeline Integration: It is the first package to integrate theory specification, derivation, diagrammatic rule generation, tensor tracing, and optimized code generation into a single workflow.
3. Advanced Routing and Identification: It supports multi-loop momentum routing and topological identification of diagrams (including disconnected ones) at any loop order, merging identical diagrams with correct symmetry factors.
4. Interoperability: FunKit includes format conversion layers to translate between its notation and those of DoFun and QMeS, facilitating integration into existing pipelines.
5. Code Generation: It provides highly optimized code generation for C++, Julia, and Fortran, specifically tailored for high-performance numerical solvers and GPU kernels.

Results and Benchmarks

The authors validate FunKit through several implementations and benchmarks:

• Implementation Examples: The package was used to derive flow equations and DSEs for scalar theories, Yukawa models, NJL models, and Yang–Mills theory. A full numerical implementation for Yang–Mills theory was provided, reproducing results from the DiFfRG framework and comparing favorably with lattice data.
• Performance Benchmarks: Comparisons against DoFun (v3.0) and QMeS (v1.2) on a 16-core AMD Ryzen 9 7945HX machine show:
  • For small expressions (e.g., scalar two-point functions), FunKit is an order of magnitude faster than competitors.
  • For large, complex expressions (e.g., six-fermion flow equations), FunKit consistently outperforms QMeS and shows parity or superiority over DoFun, with speedups of up to an order of magnitude for expressions involving thousands of diagrams.
• Feature Comparison: Table 3 in the paper details that FunKit uniquely supports arbitrary master equations, multi-index derivatives, source fields, and multi-loop routing, while also offering features like LaTeX rendering and C++/Julia/Fortran code generation which are absent in the other tools.

Significance and Claims

The paper claims that FunKit addresses a critical gap in the computational toolkit for functional QFT methods. Its significance lies in:

• Flexibility: By not being restricted to specific master equations, it allows researchers to explore new functional approaches (e.g., spectral fRG flows, flowing reparametrisations) that were previously difficult to implement.
• Efficiency: The combination of parallel processing, FORM-based tracing, and optimized code generation enables the handling of truncations that were previously computationally prohibitive.
• Usability: The modular design and extensive documentation (including example notebooks for various theories) lower the barrier to entry for complex functional derivations.

The authors acknowledge limitations, noting that the resolution of functional derivatives via product-rule expansion remains a bottleneck for extremely large systems, though this is inherent to the approach rather than the software. Furthermore, FunKit assumes translation invariance and does not provide a numerical integration framework, requiring users to embed the generated code into solvers like DiFfRG.

In conclusion, FunKit is presented as a versatile, extensible, and high-performance toolkit that enables the derivation and numerical evaluation of functional equations for a wide range of quantum field theories, bridging the gap between symbolic derivation and numerical application.