⚛️ quantum physics

GroupFunctions.jl: computing individual entries of the irreducible representations of the unitary group U(d)

GroupFunctions.jl is a Julia library that computes individual matrix elements of irreducible representations of the unitary group U(d) using Gelfand-Tsetlin patterns, offering both symbolic and numerical evaluation capabilities alongside tools for constructing operators, translating patterns to occupation-number kets, and exporting results to Mathematica.

Original authors: David Amaro-Alcalá, Konrad Szymański

Published 2026-07-14

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: David Amaro-Alcalá, Konrad Szymański

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the universe of quantum physics as a giant, invisible orchestra. In this orchestra, the Unitary Group U(d) is the conductor, and the irreducible representations are the specific musical scores the orchestra plays. Sometimes, physicists need to know exactly how one specific note (a "basis state") transforms into another note after the conductor waves their baton (the matrix operation). These specific transformations are called group functions.

Enter GroupFunctions.jl, a new digital tool written in the Julia programming language. Think of it as a super-smart, magical calculator that can write down the exact recipe for how any single note changes into any other note in this quantum orchestra.

The Magic Recipe Book

Most tools in this field are like chefs who can only taste the final soup to guess the ingredients, or they can only cook the entire massive banquet at once. But GroupFunctions.jl is different. It can write down the exact, step-by-step recipe for just one specific dish (a single matrix entry) without having to cook the whole meal first.

If you ask it, "What happens if I mix these specific quantum ingredients?" it doesn't just give you a guess or a number; it gives you a symbolic formula. It's like getting a math equation that says, "If you have ingredient A and ingredient B, the result is exactly $A^2 + \sqrt{2}AB$ ." This is crucial because sometimes you need the exact formula to understand the rules of the game, not just a rough estimate.

The "Boson" Party

One of the coolest things this tool does is help with boson sampling. Imagine a party where indistinguishable guests (bosons) walk through a maze of mirrors and beam splitters (a linear optical network). Predicting where they end up is notoriously hard for regular computers—it's like trying to count every possible way a million people could shuffle through a hallway at once.

GroupFunctions.jl helps calculate the "transition amplitude," which is basically the probability of a specific guest starting at the door and ending up at a specific chair. While other tools might simulate the whole party numerically, this tool can write down the exact mathematical expression for a single guest's journey. This is vital for testing if real quantum devices are actually doing what they claim to do.

How It Works (The Secret Sauce)

The authors didn't just guess how to do this. They chose a specific mathematical path called the Grabmeier-Kerber formula. Imagine trying to find a specific path through a massive forest of permutations (shuffles). Instead of walking every single path one by one, the tool groups together paths that lead to the same result, saving a ton of time.

However, the paper is very clear about its limits: this tool is single-threaded, meaning it does the work one step at a time, not all at once. On a specific laptop (an AMD Ryzen 7 PRO 4750U), calculating a complex example took about 4 seconds after the computer warmed up. It's fast for a symbolic calculation, but it's not magic—it still has to do the heavy lifting.

What It Is NOT

It's important to know what this tool doesn't do. It is not designed to:

Calculate the "Clebsch-Gordan coefficients" (a different type of math puzzle) for SU(d) groups—that's what other tools like SUNRepresentations.jl do.
Integrate over groups (finding the average over all possibilities) like IntegrateUnitary.jl.
Simulate the entire Gaussian boson sampling process like The Walrus.

The paper explicitly states that while other packages exist, none were designed to compute individual representation-matrix entries symbolically until now.

The Bottom Line

The authors have built a tool that lets physicists and mathematicians see the exact, symbolic "DNA" of how quantum states transform. They proved it works by testing it on examples, like calculating the transition for 7 bosons in a U(10) system, and they even used it to help evaluate group characters in randomized benchmarking.

They are confident in the math behind it, having developed the design and proof of correctness themselves, though they did use AI assistants to help polish the code and the documentation. The tool is free, open-source, and ready for anyone to install with a simple command: ] add GroupFunctions. It's a new key for unlocking the precise, symbolic secrets of the quantum orchestra.

Technical Summary of GroupFunctions.jl

Problem Statement
Representations of the unitary group $U(d)$ are fundamental to various subfields of physics and mathematics, particularly in quantum optics and algebraic combinatorics. A central computational task in these fields is evaluating individual matrix elements of irreducible representations (irreps), known as "group functions." These elements, denoted as $D^{(\lambda)}_{\text{out,init}}(U) = \langle \text{out} | D^{(\lambda)}(U) | \text{init} \rangle$ , are required for tasks ranging from calculating transition amplitudes of photons in linear optical networks to characterizing quantum devices and analyzing symmetry properties.

While numerical estimation is often sufficient for some applications, other contexts—such as deriving exact symbolic expressions for transition amplitudes or characters—require precise symbolic computation. Existing software solutions address related but distinct problems: some compute Clebsch-Gordan coefficients (e.g., SUNRepresentations.jl), others provide indirect numerical access to group functions (e.g., RepLAB), and some focus on symbolic integration over groups (e.g., IntegrateUnitary.jl). Libraries dedicated to quantum optics (e.g., BosonSampling.jl, The Walrus) typically model devices numerically or compute specific amplitudes like permanents, but none are designed to compute individual representation-matrix entries symbolically. Furthermore, assembling an entire representation matrix is often computationally inefficient when only a single entry is required.

Methodology
The paper introduces GroupFunctions.jl, a Julia library designed to compute these individual matrix elements symbolically or numerically. The library operates within a carrier-space basis enumerated by Gelfand-Tsetlin (GT) patterns.

The core algorithmic approach relies on the Grabmeier-Kerber formula, which expresses a matrix element as a sum of monomials in the entries of the input matrix $U$ . These monomials are weighted by the irreducible representation and the specific basis states involved. The implementation optimizes this process by:

Enumerating Double Cosets: Instead of iterating over all permutations in the symmetric group $S_N$ (where $N$ is the number of boxes in the Young diagram), the algorithm groups permutations that contribute identical monomials.
Efficient Summation: It constructs double cosets and iterates over their representative permutation elements, significantly reducing the computational overhead compared to a naive permutation-by-permutation approach.
Internal Representation: Basis states are represented internally as semistandard Young tableaux, while the user interface exposes equivalent GT patterns via the GTPattern data structure.

The library supports symbolic input matrices (using SymEngine.Basic) and provides utility functions to translate GT patterns into occupation-number kets, construct input unitaries from common quantum optics parameterizations, and compute associated Schur functions.

Key Contributions

Symbolic Computation of Individual Entries: GroupFunctions.jl is the first package, to the authors' knowledge, capable of computing individual entries of $U(d)$ representation matrices symbolically.
Unified Framework: It provides a unified method for computing matrix elements for irreps specified by integer partitions of length at most $d$ , handling both symbolic and numerical inputs.
Specialization for Quantum Optics: The library includes specific tools for quantum optics scenarios, such as evaluating transition amplitudes for boson sampling and handling symmetric irreps (modeling fully indistinguishable bosons).
Export Capabilities: Results can be exported in a format compatible with Mathematica, facilitating further symbolic manipulation.

Results and Performance
The paper demonstrates the library's capabilities through examples, including the symbolic computation of $SU(2)$ group functions (reducing to Wigner D-functions) and a $U(10)$ symmetric irrep involving 7 bosons.

Performance: On an AMD Ryzen 7 PRO 4750U CPU, the symbolic computation of a specific $U(10)$ matrix element took approximately 4 seconds after compilation warmup, without reusing cached results.
Scalability: The computational cost is governed by three factors: the group dimension $m$ , the dimension of the Gelfand-Tsetlin space $d_\lambda(m)$ , and the dimension of the symmetric group irrep $f^\lambda$ (the number of standard Young tableaux). The authors note that while the underlying work involves permutations that can approach $N!$ , the practical bottleneck is usually the growth of $N$ or the dimension $f^\lambda$ rather than increasing $m$ via trailing zeros.
Application: The library has already been utilized to numerically evaluate $SU(d)$ group characters in randomized benchmarking.

Significance
The significance of GroupFunctions.jl lies in its ability to provide exact symbolic solutions for individual representation matrix entries, a capability previously unavailable in existing software ecosystems. By avoiding the need to assemble entire representation matrices, the library offers a more efficient route for specific calculations required in algebraic combinatorics and quantum physics. The authors position the tool as a specialized resource for researchers needing exact analytical expressions for transition amplitudes or character evaluations, filling a gap between purely numerical optical simulators and general-purpose group theory libraries that lack direct symbolic entry computation.