IntegrateUnitary.jl: A Julia package for symbolic integration over Haar measures

This paper introduces \texttt{IntegrateUnitary.jl}, an open-source Julia package that implements the Weingarten calculus and Wick contractions to perform exact symbolic integration of polynomial functions over various compact groups and random matrix ensembles, offering tools for quantum information science and random matrix theory.

The Gist

Imagine you are trying to predict the average behavior of a giant, chaotic dance floor where thousands of dancers (matrices) move in perfect, random synchronization. In the world of quantum physics and advanced mathematics, this dance floor is called the Haar measure, and the dancers are special types of matrices (like Unitary, Orthogonal, or Symplectic groups).

Scientists often need to calculate the "average" outcome of complex interactions on this dance floor. For example, if you multiply these matrices together in a specific pattern, what is the average result? Doing this by hand is like trying to count every single grain of sand on a beach while a hurricane blows; it's mathematically possible but practically impossible for complex patterns.

IntegrateUnitary.jl is a new, open-source software tool (written in the Julia programming language) that acts as a super-powered calculator for these specific types of "dance floor" averages. Here is how it works, explained through simple analogies:

1. The "Universal Translator" for Math

Usually, to solve these problems, a mathematician has to translate a high-level idea (like "the trace of a product of matrices") into a messy, low-level list of thousands of individual numbers and indices. It's like having to write out every single letter of a book to find the average word length.

IntegrateUnitary.jl skips the messy translation. It has a "Symbolic Trace Logic" that understands the high-level math directly. You can tell it, "Calculate the average of this complex loop of matrices," and it automatically figures out the underlying math without you needing to write out the thousands of tiny steps. It's like speaking to a translator who instantly knows the answer without needing you to spell out every word.

2. The "Magic Formula" (Weingarten Calculus)

The secret sauce behind this tool is something called Weingarten calculus. Think of this as a master key or a magic formula that turns a chaotic sum of millions of possibilities into a neat, clean fraction.

• The Old Way: To find the average, you might have to list every possible permutation of the dancers, calculate the result for each, and add them up.
• The IntegrateUnitary Way: It uses the Weingarten formula to instantly know the answer based on the shape of the pattern, not the individual steps. It's like knowing that if you roll a die 100 times, the average is 3.5, without actually rolling it 100 times.

3. Handling "Variable Sizes" (Symbolic Dimensions)

One of the tool's coolest features is that it can handle the size of the dance floor as a variable (let's call it $d$) rather than a fixed number.

• Other tools often require you to say, "The dance floor has 10 dancers," and then they give you an answer for 10. If you want the answer for 11, you have to run the whole calculation again.
• IntegrateUnitary.jl can give you a formula like "The answer is $2/d$." This means you get the rule for any size dance floor instantly. It can even tell you what happens when the dance floor becomes infinitely huge (asymptotic expansions), which helps scientists understand the "big picture" behavior of quantum systems.

4. A Library of Different Dance Styles

The software doesn't just handle one type of dance. It supports a huge variety of "ensembles" (groups of matrices), including:

• Unitary & Special Unitary: The standard quantum dance.
• Orthogonal & Symplectic: Dances with specific symmetry rules (like mirrors or twists).
• Gaussian & Ginibre: Dances where the steps are random numbers drawn from a bell curve.
• Permutation Groups: Dances where the dancers just swap seats.
• Unitary Designs: Dances that pretend to be random but are actually a smaller, simpler set of moves (useful for testing quantum computers).

5. Speed and Efficiency

The paper compares this new tool to existing calculators (like RTNI and Haarpy). The results show that IntegrateUnitary.jl is significantly faster, especially for complex, high-degree calculations.

• The Analogy: If other tools are like a bicycle, IntegrateUnitary.jl is a high-speed train. For simple tasks, they might be similar, but as the math gets harder (higher degrees), the new tool stays fast while the others slow down drastically.
• It achieves this speed by using the Julia language's ability to compile code just-in-time and by "remembering" (caching) answers it has already calculated so it doesn't have to do the work twice.

6. What It Can't Do (The Boundaries)

The authors are honest about the tool's limits:

• Pure Trace Moments: For certain very specific types of sums involving the "trace" (a specific sum of diagonal numbers), the tool needs you to give it a concrete number for the size of the dance floor (e.g., $d=10$) rather than a variable. It can't give a general formula for these specific cases yet.
• Complexity Ceiling: Because the math involves factorials (which grow incredibly fast), the tool is practical for polynomials up to a certain degree (around degree 10-12). Beyond that, the number of terms becomes too huge for any computer to handle symbolically in real-time.

Summary

IntegrateUnitary.jl is a powerful, open-source calculator that lets scientists compute the average behavior of complex, random quantum systems without getting bogged down in messy manual math. It acts as a bridge between abstract theory and practical calculation, offering speed, flexibility with variable sizes, and the ability to handle a wide variety of mathematical "dance styles" that were previously difficult or impossible to compute efficiently.

Technical Summary

Technical Summary of IntegrateUnitary.jl: A Julia package for symbolic integration over Haar measures

Problem Statement
Symbolic integration over the Haar measure of compact groups is a fundamental technique in random matrix theory (RMT) and quantum information theory (QIT), essential for characterizing typical properties of quantum systems, such as average entanglement entropy, and for analyzing quantum chaos and unitary $t$-designs. While closed-form solutions exist via the Weingarten calculus, their practical evaluation is hindered by the combinatorial complexity of symmetric group sums and representation theory intricacies. Existing software tools, such as the Mathematica-based RTNI and the Python library Haarpy, face limitations in extensibility, performance, and the ability to handle symbolic dimensions ($d$) natively across diverse workflows. Furthermore, translating high-level, coordinate-free mathematical expressions (e.g., traces of products) into the index-based tensor contractions required by Weingarten calculus often necessitates error-prone manual preprocessing by the user.

Methodology
The paper presents IntegrateUnitary.jl, a pure Julia package designed to automate and optimize symbolic integration over Haar measures. The core methodology relies on the Weingarten calculus, which expresses integrals of polynomial functions over compact groups as sums over combinatorial sets (permutations for unitary groups, pair partitions for orthogonal and symplectic groups).

Key methodological components include:

• Unified Integration Pipeline: The package normalizes input expressions using SymbolicUtils.jl, expands them into monomials, and dispatches them to specialized engines based on the measure type (Unitary, Orthogonal, Symplectic, Gaussian, etc.).
• Symbolic Dimension Support: Leveraging the polynomial nature of group characters and Schur functions, the package computes many integrals as exact rational functions of the dimension $d$. This allows for the derivation of exact asymptotic expansions and universal scaling laws via automated Laurent series, rather than requiring concrete integer dimensions for every calculation.
• Symbolic Trace Logic: A high-level interface allows users to input coordinate-free expressions (e.g., tr(U * A * U' * B)). The system automatically reconstructs the necessary Weingarten graphs or Wick contractions from these index-free inputs, eliminating manual index management.
• Algorithmic Optimizations:
  • Unitary Groups: Uses the Murnaghan-Nakayama rule for character computation and the Hook-Content formula for representation dimensions, enabling efficient handling of symbolic $d$.
  • Orthogonal/Symplectic Groups: Employs a duality relation where symplectic integrals are computed by reusing the orthogonal engine with a signed dimension parameter ($d \to -d$), avoiding separate matrix inversions.
  • Gaussian/Ginibre Ensembles: Implements Wick's theorem (Isserlis' theorem) for moment contraction.
  • Memoization: Caches characters, dimensions, and Weingarten values to accelerate repeated tasks.
• Tensor Network Integration: A native bridge to ITensors.jl allows for the symbolic averaging of large-scale random tensor networks by analyzing contraction topologies and expanding them into sums of deterministically contracted tensors weighted by Weingarten functions.

Key Contributions
The paper introduces a comprehensive Julia package that addresses the limitations of existing tools through several distinct features:

1. Diverse Ensemble Support: Unified integration over compact groups ($U(d)$, $O(d)$, $Sp(d)$, $SU(d)$), circular ensembles (CUE, COE, CSE), Gaussian and Ginibre ensembles, permutation groups, random pure states, Stiefel manifolds, and unitary $t$-designs.
2. Native Symbolic Dimensions: Unlike many predecessors, IntegrateUnitary.jl treats $d$ as a native symbolic variable, supporting exact rational results and automated asymptotic expansions ($1/d$ series) for a wide range of observables.
3. High-Level Abstraction: The symbolic trace logic and SymbolicMatrix types allow users to define complex integrals without explicit index contraction, reducing the potential for errors and aligning the code structure with mathematical notation.
4. Performance: By leveraging Julia's just-in-time (JIT) compilation and efficient caching, the package handles high-degree moments and large-scale symbolic computations more efficiently than existing tools.
5. HCIZ Integrals: Implementation of the Harish-Chandra-Itzykson-Zuber integral for both symbolic and numeric eigenvalue inputs, with specific handling for degenerate spectra.

Results and Benchmarks
The authors provide extensive benchmarks comparing IntegrateUnitary.jl against Haarpy and RTNI:

• Performance: The package demonstrates significant speedups, particularly for high-degree moments. For unitary diagonal moments ($|U_{11}|^{2k}$) with symbolic $d$, speedups over Haarpy range from 12.0$\times$ to 88.5$\times$. For orthogonal groups, the advantage is even more pronounced, with speedups exceeding $2.7 \times 10^4\times$ for degree 10 moments, attributed to IntegrateUnitary.jl's optimized univariate solver versus Haarpy's full matrix inversion approach.
• Scalability: The package efficiently handles high-degree polynomials (up to $2k \approx 10\text{--}12$ on standard hardware) and scales effectively with dimension $d$ for tensor network integrations.
• Correctness: All results are verified against known exact values, asymptotic limits, and theoretical expectations (e.g., Page's result for average entanglement).
• Limitations: The paper notes that pure trace moments $|tr(U)|^{2k}$ depend on $d$ as a step function and require concrete integer dimensions. Similarly, $SU(d)$ integration is currently limited to balanced polynomials, and HCIZ integrals with degenerate symbolic eigenvalues require manual handling.

Significance
The paper positions IntegrateUnitary.jl as a critical tool for theoretical physicists and quantum information scientists. By bridging the gap between abstract Weingarten calculus and practical computation, it enables the rigorous derivation of properties for random quantum channels, entanglement statistics, and scrambling measures without relying on brittle numerical sampling. The package's ability to handle symbolic dimensions and high-level trace logic significantly reduces the cognitive load and potential for error in complex derivations. The authors assert that the tool facilitates the study of phenomena previously intractable due to combinatorial complexity, serving as a versatile environment for both theoretical derivations and numerical experiments. Future work is outlined to extend support to exceptional Lie groups and refine finite-$d$ corrections for $SU(d)$.