Quadratic Goldreich-Levin Algorithm
- The Quadratic Goldreich-Levin Algorithm is a method for extracting quadratic phase functions that maximize correlation in Boolean functions.
- It utilizes higher-order Fourier analysis and symplectic geometry to achieve near-optimal query and time complexity in function decomposition.
- The algorithm supports applications in learning theory, pseudorandomness, and error-correcting codes, bridging theory with practical advances.
The Quadratic Goldreich-Levin (QGL) algorithm is a cornerstone result in higher-order Fourier analysis, algorithmic additive combinatorics, and coding theory. It generalizes the classical Goldreich-Levin algorithm—originally designed for extracting large linear Fourier coefficients—to discover and exploit quadratic structure in bounded functions over vector spaces such as . The QGL algorithm efficiently identifies, with near-optimal computational resources, quadratic phase functions maximizing the correlation with a given function, and underpins advances in learning theory, pseudorandomness, and polynomial Freiman-Ruzsa decompositions (Tulsiani et al., 2011, Castro-Silva et al., 6 Apr 2026, Briët et al., 19 May 2025).
1. Foundation: From Linear to Quadratic Fourier Decomposition
The classical Goldreich-Levin (GL) algorithm provides an efficient procedure for list-decoding large linear Fourier coefficients of Boolean functions . Its decomposition can be framed as , where and has small correlation with any linear phase.
Quadratic Fourier analysis generalizes this by seeking to approximate using quadratic phases , a degree-2 polynomial, enabling stronger pseudorandomness guarantees with respect to quadratics. The main theorem asserts that any bounded function can be decomposed as
where each 0 is a quadratic form, 1 with 2, and the remainder 3 is quadratically uniform, satisfying 4—where 5 denotes the Gowers uniformity norm of order 3 (Tulsiani et al., 2011).
2. The Quadratic Goldreich-Levin Algorithm: Core Construction
The QGL algorithm is designed to, with high probability, output a quadratic polynomial 6 such that the correlation 7 is within an additive 8 of the maximal correlation achievable by any quadratic phase. The method leverages higher-order analysis and reductions to quantum learning-inspired routines. The state-of-the-art algorithm achieves:
- Query complexity: 9.
- Running time: 0.
- Success probability: at least 1.
- Output: quadratic 2 with
3
At a high level, the QGL algorithm proceeds in three stages (Briët et al., 19 May 2025, Castro-Silva et al., 6 Apr 2026):
- List decoding: List all stabilizer states (quadratic/affine phases supported on affine subspaces) that are local maximizers of the normalized correlation.
- Phase Conversion: For each such stabilizer state, output the corresponding quadratic phase(s).
- Correlation Estimation and Selection: Estimate the true correlation via sampling and select the phase with maximal observed correlation.
The central discovery is that this approach—by blending robust Lagrangian sampling with symplectic geometry—produces a practical polynomial-time procedure that nearly matches information-theoretic lower bounds for query complexity (Briët et al., 19 May 2025).
3. Technical Components, Notation, and Subroutines
Key definitions used throughout the QGL algorithm are as follows (Briët et al., 19 May 2025, Castro-Silva et al., 6 Apr 2026):
- Quadratic phase function:
4, with phase 5.
- Correlation:
6.
- Discrete derivative:
7.
- Fourier transform of derivative:
8.
- Gowers 9 norm:
0.
Principal subroutines:
- LagrangianSampling: Repeatedly samples from the "Bell-difference" distribution 1, with 2, to generate a basis for the Lagrangian subspace (maximal isotropic with respect to symplectic inner product) defining a stabilizer state.
- StabilizerSampling: From the found Lagrangian, recovers the relevant quadratic phases via Gaussian elimination and linear GL passes on cosets to find potential shifts.
- ListDecoding: Aggregates above steps with sufficient repetition and final estimation to ensure, with probability 3, inclusion of a maximally correlating quadratic phase.
Running times of all subroutines are polynomial in 4 and quasipolynomial in 5.
4. Structural Insights and Algebraic Framework
A defining conceptual advance in QGL is connecting quadratic Fourier analysis to symplectic geometry. The space 6 carries a symplectic form 7. Lagrangian subspaces (maximal isotropics) in this geometry correspond to stabilizer states, which are the extremizers of the 8 norm. Each quadratic phase maximally correlating with 9 arises from a unique Lagrangian, providing a geometric "label" to the phase function (Castro-Silva et al., 6 Apr 2026, Briët et al., 19 May 2025).
Integration step: Recovering 0 from the pattern of large 1 amounts to identifying a Lagrangian subspace in this geometry and reconstructing the underlying quadratic form. This perspective underpins algorithmic advances and clarifies why such decompositions provide strong structure random decompositions.
5. Applications: Reed-Muller Codes, Inverse Theorems, and Decomposition
The QGL algorithm enables several fundamental algorithmic and structural results:
- Self-correction of quadratic Reed-Muller (2) codes:
For a function 3 at Hamming distance 4 from some quadratic phase (a codeword), QGL finds a codeword within distance at most 5, with 6 in earlier algorithms and the optimal 7 in more recent ones (Tulsiani et al., 2011, Briët et al., 19 May 2025).
- Algorithmic inverse theorem for 8:
If 9, QGL outputs 0 with 1 for some absolute constant 2 (Briët et al., 19 May 2025).
- Efficient structure vs. randomness decompositions:
Any bounded 3 can be efficiently decomposed as a sum of polynomially many quadratic phases plus an error term that is small in both 4 and 5 norm (Briët et al., 19 May 2025, Tulsiani et al., 2011).
These capabilities extend prior methods (which depended on exponential search or specialized combinatorial theorems) to efficient algorithmic protocols with wide-ranging impact.
6. Complexity Bounds and Optimality
The QGL algorithm achieves query complexity 6, which matches the information-theoretic lower bound of 7 up to logarithmic factors (Briët et al., 19 May 2025). Earlier procedures (Tulsiani et al., 2011) incurred exponential factors in 8 for achieving non-trivial correlation, but the contemporary algorithm attains a near-optimal correlation, even in list-decoding and decomposition tasks.
A summary of query and time complexity bounds across papers:
| Paper | Query Complexity | Time Complexity | Correlation Guarantee |
|---|---|---|---|
| (Tulsiani et al., 2011) | poly9·exp0 | poly1·exp2 | 3 |
| (Castro-Silva et al., 6 Apr 2026, Briët et al., 19 May 2025) | 4 | 5 | opt6 |
The algorithm is thus polynomial in 7 and quasipolynomial in 8, which is conjectured to be optimal for this regime.
7. Comparison to Prior Techniques and Broader Impact
Prior to the most recent QGL algorithms, approaches for algorithmic inverse theorems and self-correction beyond list-decoding radius leveraged combinatorial and additive number-theoretic machinery with significant computational overhead (Tulsiani et al., 2011). Modern implementations (Briët et al., 19 May 2025, Castro-Silva et al., 6 Apr 2026) benefit from "dequantized" quantum learning protocols; their LagrangianSampling draws explicitly on Bell-difference sampling used for learning quantum stabilizer states, adapted to the classical query model.
The connection to symplectic geometry not only explains the algebraic structure underpinning quadratic phases but also provides practical boosts in the algorithmic extraction of Lagrangians, making highly-structured decompositions effective for applications in coding theory (optimal correction of Reed-Muller codes), additive combinatorics (algorithmic polynomial Freiman-Ruzsa), and learning theory (efficient Fourier learning with respect to quadratic structure).
Continued advances exploit the symplectic–Fourier correspondence, quantum-inspired sampling, and robust structure-generation properties, pushing the performance and scope of higher-order Goldreich-Levin algorithms further. These developments position the QGL algorithm as a centerpiece of modern algorithmic harmonic analysis and its intersection with quantum information (Castro-Silva et al., 6 Apr 2026, Briët et al., 19 May 2025, Tulsiani et al., 2011).