Discrete Fourier Transform Complexity: How OpenAI Cracked the n log n Barrier

The Fast Fourier Transform has spent decades turning quadratic calculations into manageable work. OpenAI now presents a proof that discrete Fourier transform complexity can fall below the familiar $O(n\log n)$ scale, at every input length. The improvement is asymptotic, deterministic, and exact, but it belongs to a computational model with unrestricted complex coefficients and supplied roots of unity.

The September 25 preprint gives a logarithmic exponent smaller than one by a minuscule amount. It includes preparation and indexing costs. It provides no practical floating-point speedup. Understanding that distinction makes the result more interesting: the proof challenges a mathematical barrier while leaving everyday FFT engineering largely untouched.

1. Discrete Fourier Transform Complexity: From Quadratic Work to the FFT Barrier

For a complex input vector $x=(x_0,\ldots,x_{n-1})$, the paper studies the unnormalized DFT:

Here $i^2=-1$, $n$ is the vector length, and $j$ selects an output coordinate. The positive exponent follows the manuscript’s convention. Unnormalized means there is no scaling factor in this formula.

At length four, the zeroth output simply adds all four inputs. The other outputs combine them with powers of $i$. Evaluating every output separately takes quadratic arithmetic work. FFT factorizations reuse intermediate combinations to reach $O(n\log n)$ work, including arbitrary lengths through convolution reductions.

1.1. Exact DFT Key Facts

An upper bound describes an available algorithm. Calling it optimal requires a lower bound for every permitted algorithm. That second statement depends on what operations the model allows.

2. Why Was n log n Believed to Be the FFT Lower Bound?

The FFT’s repeated layers make logarithmic overhead look unavoidable. Historical lower bounds gave that intuition mathematical support, but within specific models.

Morgenstern’s determinant argument concerns the unnormalized Fourier transform when coefficients are bounded. Roughly, each permitted operation can increase the relevant determinant measure only by a controlled amount. Building the Fourier matrix then requires sufficiently many operations.

Ailon’s entropy argument addresses the normalized Fourier transform on $n$ coordinates using unitary two-coordinate gates. Such gates preserve the Euclidean norm. Later work also studies restrictions on intermediate conditioning, which measures sensitivity to perturbations.

These restrictions matter. Unrestricted coefficients and exact intermediate values remove constraints used by those arguments. An FFT lower bound for bounded coefficients cannot automatically become a theorem about unrestricted complex-linear computation.

The manuscript also separates its advance from earlier constant-factor improvements. Reducing the leading constant in FFT complexity preserves the $n\log n$ growth scale. Reducing the exponent of the logarithm changes that scale. Both are useful mathematics, but they answer different questions about optimality.

3. What OpenAI Actually Claims: The Exact DFT Theorem and Its Assumptions

Theorem 1.1 presents one deterministic algorithm for every positive integer length and every complex input. Its sharper running-time estimate is:

The constant $\theta=\log_m\lambda$ is approximately $0.999999999999789356$, with exact definitions supplied below. Corollary 1.2 simplifies the estimate to $O\left(n(\log n)^{1-10^{-13}}\right)$. The iterated logarithm has not disappeared for free. The corollary trades some exponent improvement to absorb it.

Complex field operations have unit cost. Input processing uses addition, subtraction, and multiplication by prepared, input-independent scalars. Division occurs only during preparation, with nonzero denominators established. Complex coefficients and intermediate magnitudes are unrestricted.

Integer addresses use a fixed number of logarithmic-size words. That requirement limits address size, not complex-register precision. One specified root of unity, of polynomial order, is supplied. Other scalars, schedules, and array organization are charged.

The root assumption prevents a hidden algebraic shortcut. Rational field operations alone cannot manufacture roots of arbitrarily large order from rational constants. The algorithm states which root it receives and shows how that root supplies the others. Its access to exact algebraic information is explicit.

OpenAI included the result in its October 6 mathematics release. The relevant achievement is this stated theorem, rather than an inference from the broader AI mathematical proofs coverage.

4. The Two-Coordinate Matrix Behind OpenAI’s New Algorithm

The construction starts with a small complex matrix:

For $k$ binary coordinates, its tensor power $C^{\otimes k}$ acts on $2^k$ values. Applying its factors separately costs $O(k2^k)$. The proof seeks a smaller exponent of $k$.

Its starting network has two banks of wires and many auxiliary wires. Each forward invocation performs eight updates: subtract the auxiliaries’ contribution, add the source into the auxiliaries, add their revised contribution, then restore them. Algebraic cancellation produces $(x,y)\mapsto(x,y+x)$ for arbitrary initial auxiliary values.

Three stages, forward, inverse in the opposite direction, and forward again, exchange the banks with a sign: $(X,Y)\mapsto(-Y,X)$. Every auxiliary value returns unchanged.

Arbitrary initial values are essential. Recursive calls borrow coordinates already holding data. Requiring fresh zero-filled workspace would break the intended interface and cost accounting. The phase network also appears in the related integer multiplication construction, whose later precision and tape arguments belong to a separate model.

5. How Binary Frames Create a Strict Saving in Tensor Operations

The ingenious step is to replace each scalar wire with an array and attach binary-subspace labels to gates and endpoints. These labels specify coordinate frames $\Phi_U$, transformations associated with a subspace $U$ of a binary vector space.

A scalar gate mixes arrays. A common frame transforms their address coordinates. Those actions commute, allowing adjacent frame changes to cancel throughout the network.

Moving between nested suitable subspaces costs directional kernels for the dimensions added or removed. A directional kernel combines an array with its binary-address translation. On paired addresses it acts like $C$, or its inverse with a translation.

The paper explicitly counts these residual dimensions. If $W$ denotes the physical roles and $s$ their total directional cost, the saving is $\Delta=Wm-s>0$. Its exact value is $6{,}871{,}402{,}692{,}000{,}000$.

This is a finite accounting victory, not an approximate transform. The frames make every physical role contribute correctly, including auxiliary roles. Walsh matrices help establish the identities, but the algorithm does not execute those Walsh transforms. The positive saving will survive padding and become a recursive multiplier.

The binary space organizes addresses, while the stored values remain complex numbers. Confusing those two spaces would incorrectly suggest a finite-field Fourier algorithm. The subspace labels determine which pairs interact. They do not change the arithmetic domain of the input or output.

6. The Recurrence That Breaks the n log n Barrier

The network uses $m=10^6$ binary dimensions. Padding its role count to $W_*=2^{71}$ preserves the absolute saving and gives $\lambda=m-\Delta/W_*<m$.

Let $T_C(k)$ be the cost of transforming $W_*$ arrays of length $2^k$, and normalize by their total length: $t(k)=T_C(k)/(W_*2^k)$. Splitting $k$ into blocks of $m$ dimensions yields:

Here $A$ is a fixed overhead covering pointwise gates, permutations, leftover dimensions, and batch handling. The recursive argument shrinks by a factor of approximately $m$. Crucially, fiber counts divide exactly into full batches. No partial batch forces wasted workspace or extra transforms.

Unrolling the recurrence gives a geometric sum with about $\log_m k$ levels. Consequently $t(k)=O((k+1)^\theta)$, where $\theta=\log_m\lambda<1$. A single tensor transform therefore costs $O(2^k(k+1)^\theta)$.

If the multiplier were $m$, this reasoning would retain exponent one. The strict inequality supplies the entire power saving. The algorithm makes that saving survive recursion by transforming arbitrary values on all roles.

The normalized cost isolates overhead per stored value. Recursion reduces the number of active binary coordinates, while batching accounts for all values still being transformed. This distinction explains why a saving in a finite dimension budget can become a bound for an unbounded family of arrays.

7. Newton Interpolation and Toeplitz Matrices: Compiling the Fourier Transform

A faster tensor kernel still needs a bridge to Fourier matrices. Newton interpolation supplies it by viewing $F_r$ as polynomial evaluation at successive powers of a primitive root.

Changing to the Newton basis makes evaluation triangular. Symmetry of the Fourier matrix and uniqueness of triangular factorization then give:

Here $N$ is lower triangular, $D_N$ contains its diagonal entries, and $N^T$ is its transpose. Moreover, $N$ factors into diagonal matrices and a lower triangular Toeplitz matrix. Toeplitz entries depend on the difference between row and column indices, connecting their action to convolution.

The compiler recursively handles triangular blocks and their cross updates through convolution circuits. It measures the actual register requirements of candidate chunks before choosing a size. Borrowed coordinates can hold arbitrary values and are restored before reuse.

The resulting Fourier word uses exactly $r$ coordinates and $O(1+\log^4 r)$ slots. That is a layer count, not the full arithmetic cost of a length-$r$ transform. Preparation is polynomial in $r$. Later, the algorithm chooses small local widths so that preparation remains affordable.

8. Synchronizing Fourier Circuits Without Losing the Complexity Saving

The compiler expresses its words through monomial layers, which permute and scale coordinates, and shear layers, which add a multiple of one coordinate to another. Shears are converted into a fixed pattern using $C$ pair slots.

Padding with identity operations lets many local Fourier circuits share a common schedule. Across several axes, a simultaneous pair slot partitions the array into sectors. Choosing a pair on $k$ axes produces a sector carrying $C^{\otimes k}$. Singleton choices leave those axes inactive.

The fast tensor algorithm can now process each sector. However, repeatedly scanning every axis to calculate every entry’s address would reintroduce excessive work.

The paper instead traverses a tree of mixed-radix prefixes. Each extension updates accumulated addresses and coefficients in a fixed number of operations. Because every internal node has at least two children, the total node count is linear in the number of array entries.

This pays for packing sectors, executing them, and undoing the packing. Address arithmetic is part of the proof. Ignoring it could make the advertised saving vanish before any Fourier output appeared.

9. From Special Transform Sizes to Arbitrary Lengths Using Prime Factors

The synchronized construction prefers many small, coprime axes. The working length begins with the product $R_\ell$ of the first $\ell$ odd primes, taking the largest such product no greater than $2n$.

Multiply it by the smallest suitable power of two to obtain $L=R_\ell2^e$ with $2n\leq L<4n$. Thus, the working array remains proportional to the requested input length. The power of two fills a size gap without adding a large difficult axis.

Elementary prime estimates give $\ell=\Theta(\log n/\log\log n)$, while individual factors remain polynomially bounded in $\log n$. No prime number theorem is needed for this estimate.

Chinese remainder indexing turns the length-$L$ Fourier transform into coprime tensor factors, with appropriate permutations. These permutations also use linear traversal work.

The odd-prime axes receive synchronized compiled circuits. The remaining power-of-two axis uses a conventional radix-two FFT. The new algorithm therefore incorporates classical FFT machinery while changing the overall complexity accounting. Merely solving a sparse collection of convenient lengths would not establish the all-length theorem.

10. Bluestein’s Chirp Reduction and the Final Complexity Bound

Bluestein’s identity connects the requested transform to convolution. Set $\eta=e^{2\pi i/(2n)}$. Then:

Multiply input coordinate $x_k$ by its chirp $\eta^{k^2}$, convolve with the fixed sequence $\eta^{-u^2}$, then multiply output $j$ by $\eta^{j^2}$. Padding at length $L$ prevents unwanted wraparound in the required outputs.

The computation uses three full transforms: two forward and one inverse. Transforming the fixed convolution operand counts as preparation. Its pointwise products with variable data are multiplication by prepared scalars, preserving input linearity.

Chirp tables take linear work through successive ratios. A supplied root of order $D_*<1024n^3$ generates the required initial roots, with extraction charged.

Substituting the prime-factor count into the synchronized cost gives Theorem 1.1’s sharper bound. The proof establishes $\theta<1-2\cdot10^{-13}$. Eventually, $(\log\log n)^{4-\theta}$ grows more slowly than $(\log n)^{10^{-13}}$, producing the simplified corollary. This absorption is asymptotic, not a numerical shortcut for ordinary inputs.

11. Why the New FFT Bound Does Not Translate Into Practical Speedups

The constants are enormous, and the paper offers no useful crossover estimate. Its role padding alone involves $2^{71}$ arrays in the fixed construction. Exact complex arithmetic treats operations on arbitrarily precise values as unit-cost actions. Hardware does not.

There is also no finite-precision error analysis or numerical-stability guarantee. Unrestricted intermediate magnitudes can matter greatly when arithmetic rounds. The theorem does not establish a faster implementation for existing FFT libraries, GPUs, or signal-processing workloads.

11.1. FFT Time Complexity: What the Bounds Compare

Corollary 1.3 extends the same sharper bound to exact linear convolution and multiplication of complex polynomials of degree below $n$. Unlike the input-linear DFT algorithm, it permits general field multiplication for pointwise products of two variable inputs.

It does not establish integer bit complexity, a finite-field result, or a stable numerical algorithm. As with edit distance approximation and practical alignment, the useful question is whether the theorem’s cost model and guarantees match the application.

Polynomial coefficients illustrate the extension directly: multiplying two degree-below-$n$ polynomials requires their coefficient convolution, with $2n-1$ possible output positions. The proof pads and transforms these coefficients exactly, retaining its arithmetic assumptions throughout.

12. Has OpenAI’s Fourier Transform Proof Been Verified, and What Remains Open?

As checked on October 12, 2026, OpenAI’s Problem 130 formalization documentation reports two scopes. One gives arbitrarily small normalized exact-circuit cost along an unbounded sequence of lengths. A separate uniform formalization gives fixed deterministic programs for every positive length, covering exact DFT and full convolution with the simplified power-saving bound, including root-order selection and scalar preparation.

The supplied-root and unrestricted-coefficient assumptions remain. The synthesis appendix’s extraction, search, and printer uniformization lie outside the selected statements. The documentation does not identify the sharper iterated-logarithm estimate as its uniform comparator statement.

These are repository-reported formalization scopes, without an independent rebuild reported here. The checked primary sources also do not establish completed independent peer review. Formalization and mathematical review answer overlapping but distinct questions, as our Lean proof explainer discusses.

The OpenAI FFT breakthrough changes the unrestricted exact-arithmetic barrier under explicit assumptions. Bounded coefficients, stable numerical computation, and practical crossover behavior remain separate questions. For discrete Fourier transform complexity, a tiny exponent can settle a large qualitative question. Follow Binary Verse AI’s AI and mathematics coverage for explanations that connect new proofs to their actual computational meaning.