In-Memory Fourier Transform Overview

• In-memory Fourier transform is a computational method that performs Fourier operations directly on primary data buffers, minimizing auxiliary workspace.
• Techniques include in-place truncated transform, processing-in-memory approaches, analog algorithms, and quantum memory platforms to boost speed and reduce resource use.
• Applications range from polynomial multiplication to sparse interpolation and advanced signal processing, maintaining efficiency under strict memory constraints.

An in-memory Fourier transform refers to computational techniques, mathematical algorithms, and system architectures that perform Fourier transform operations—either full, truncated, or generalized—in a way that greatly reduces or eliminates the need for auxiliary workspace beyond the primary data buffers, often leveraging hardware locality or taking explicit advantage of memory architectures (digital, analog, or even quantum). These methods encompass classical variants such as the in-place truncated Fourier transform (TFT), advanced processing-in-memory (PIM) implementations with crossbar or DRAM-based acceleration, analog charge-trapping arrays for large-scale frequency analysis, as well as the adaptation of Fourier transforms in specialized settings (quaternionic, generalized kernel forms) and even quantum memory platforms that directly execute Fourier-like domain swaps.

1. Algorithmic Structure and Classical In-Memory Fourier Transform

The archetype for the in-memory Fourier transform is the in-place truncated Fourier transform (TFT) (Harvey et al., 2010), which operates by recursively decomposing a polynomial $F(x)$ into even and odd components, processing and "overwriting" coefficients directly within the source buffer. The transformation follows the Cooley–Tukey strategy:

• Recursion Tree Navigation: Each node is represented as $(q, r)$ (offset, stride power), with subtree lengths $\operatorname{len}(S) = \lceil (n - q)/2^r \rceil$. The iterative traversal walks this tree without a call stack, using a constant number of pointer variables and integer counters.
• Butterfly Operation: At each node, the decomposition

$F(x) = G(x^2) + x \cdot H(x^2)$

allows new coefficients to be written as

$$\hat{F}_{2s} = \hat{G}_s + \omega_{2s}\hat{H}_s, \qquad \hat{F}_{2s+1} = \hat{G}_s - \omega_{2s}\hat{H}_s,$$

with twiddle factors computed on the fly, even in bit-reversed order to keep data in place.

• Odd-Length Correction: When a subtree has odd length, a correction is performed by combining odd-indexed coefficients:

$$v = \sum_{i=0}^{(m-3)/2} S_{2i+1} \cdot (\omega_{m-1})^i, \qquad S_{m-1} \leftarrow S_{m-1} + v\cdot\omega_{m-1}.$$

Time complexity is $O(n \log n)$, and auxiliary space is $O(1)$, making this suitable for highly memory-constrained environments or situations where buffer allocation is a bottleneck.

2. Advanced Processing-In-Memory (PIM) and Analog Implementations

Emerging hardware directions in in-memory computation utilize both digital and analog memory arrays as computational substrates for the fast Fourier transform.

• Digital PIM FFT (Leitersdorf et al., 2023, Ibrahim et al., 2023): Digital crossbar architectures (memristive, DRAM-based) host parallelized butterfly operations with configurations that optimize memory-to-arithmetic mapping ("r/2r/2rβ configurations"). Each butterfly stage is executed in $O(1)$ time for all rows, yielding an overall $O(\log n)$ latency for batched FFT computation. High-throughput batched execution is possible across multiple PIM arrays.
• Collaborative PIM-GPU Acceleration (Ibrahim et al., 2023): Practical commercial PIM units may underperform for FFT if used standalone, due to limited arithmetic throughput. Collaborative approaches partition the computation between GPU (high-throughput stages, scratchpad-amenable tiles) and PIM (memory-bound bottlenecks), employing software and hardware augmentation (e.g., "twiddle factor aware" command orchestration, multi-op ALUs).
• Analog In-Memory FFT (Xiao et al., 27 Sep 2024): Factorization of large DFTs into stages amenable to analog matrix-vector multiplication (MVM) in charge-trapping crossbar arrays overcomes area and energy scaling limits ($O(N^2)$ for direct DFT, $O(N \log_K N)$ with recursive FFT). Intermediate analog outputs are digitized, multiplied by twiddle factors, and re-input for subsequent analog DFT stages. This enables spectrogram computation and image Fourier analysis on previously inaccessible scales (e.g., 65,536-point FFT), with substantial energy and error improvements.

3. Generalized Transforms and Multiresolution Extensions

The class of Fourier-type transforms analyzed in (Gupta et al., 1 Feb 2024) extends standard definitions to kernels containing quadratic or chirped phases—fractional Fourier transform (FrFT), linear canonical transform (LCT), quadratic phase Fourier transform (QPFT)—and localized forms (windowed, Stockwell, wavelet):

• Unitarity and Group Structure: Most advanced transforms preserve $L^2$ norm ($\|\mathcal{T}f\|_{L^2} = \|f\|_{L^2}$) and admit composition laws ($$\mathcal{F}_\alpha\mathcal{F}_\beta f = \mathcal{F}_{\alpha+\beta}f$$), facilitating inversion and domain "rotation" for waveform analysis.
• Modified Convolution: Fractional convolution operators ($\star_\alpha$) maintain a Fourier-to-multiplication mapping:

$$\mathcal{F}_\alpha(f \star_\alpha g)(u) = \sqrt{2\pi}\,(\mathcal{F}_\alpha f)(u)\,(\mathcal{F}_\alpha g)(u),$$

optimizing in-memory filtering and signal-processing tasks.

Wavelet transforms and the Stockwell transform incorporate multiresolution analysis; they adapt scale/frequency tradeoffs for localized features, supporting efficient storage and parallel processing in memory-intensive architectures.

4. Entropy-Based Lower Bounds and Complexity Constraints

The formal analysis of algorithmic lower bounds for Fourier transform computation in constrained memory models is delineated in (Ailon, 2014, Ailon, 2014):

• Matrix Entropy Potential: Transformation progress is measured by increases in matrix potential (entropy/quasi-entropy), explicitly:

$$\Phi(M) = -\sum_{i,j} (M(i,j), M^{-1}(j,i)), \quad (x, y) = \begin{cases} 0, & x y = 0, \ -x y \log|x y|, & x y \neq 0 \end{cases}$$

• Lower Bound Results: Any in-memory FFT implementation (well-conditioned, $R$) requires at least $\Omega(R^{-1} n \log n)$ steps, with attempts to accelerate (to $b$ times faster) incurring $\Omega(n)$ independent bottlenecks with severe overflow/underflow along orthogonal directions.

These results imply that memory-efficient FFT cannot be further asymptotically improved—optimality is reached at $O(n \log n)$ within in-memory architectures unless one pays with substantial loss of accuracy or manageability (e.g., expanding word size).

5. In-Memory Transform Applications: Polynomial Multiplication and Sparse Interpolation

In-place TFT techniques (and their generalized in-memory versions) have enabled efficient algorithms for high-throughput polynomial multiplication and sparse interpolation (Harvey et al., 2010, Arnold, 2012):

• Polynomial Multiplication: By partitioning buffers, computing in-place TFTs/ITFTs, and performing pointwise multiplication, products of polynomials of arbitrary degree (not just powers of two) are computed using only $O(1)$ stress on auxiliary space.
• Sparse Polynomial Interpolation: Modular probing and CRT-based exponent recovery, combined with in-place TFT evaluation at sets of roots of unity (and their Chinese remainder expansions), achieve fast, memory-efficient recovery of the sparse structure.

6. Generalization: Quaternionic and Composed Function Transforms

The quaternionic Fourier transform and its Mellin and kernel extensions provide algebraic frameworks for multichannel or multidimensional data (RGB images, sensor arrays) (Hitzer, 2013, Gupta et al., 1 Feb 2024):

• Transform Structure:

$$\hat{h}(v, k) = \frac{1}{2\pi} \int_0^\infty \int_0^{2\pi} r^{-f v} h(r, \theta) e^{-g k \theta}\, d\theta\, \frac{dr}{r}$$

Dual linearity, scale and rotation invariance, and Plancherel/Parseval theorems generalize core FT properties to quaternion fields.

• Uncertainty Inequalities: Sharp versions of Hausdorff–Young and Heisenberg inequalities for quaternion FTs

$$\|\mathcal{F}_{\mu,\nu} f\|_{L^q_{\mathbb{H}}} \leq A_p^2 \|f\|_{L^p_{\mathbb{H}}}, \quad \Delta_f \Delta_{\hat{f}} \geq \frac{d}{2\pi}$$

preserve the stability of computation in energy and information.

Composed-function transform theory (Venhoek, 26 Nov 2024) provides explicit integral formulas for the Fourier transform of $f(u(t))$, enabling decomposition into two parts with clear in-memory efficiency and parallelization benefits.

7. Quantum Memory Platforms and Photonic Fourier Transform

Atomic quantum memory platforms, combining protocols such as Gradient Echo Memory and Electromagnetically Induced Transparency, achieve in-memory Fourier transform via hybrid domain swaps (Papneja et al., 12 Aug 2025):

• Storage (GEM): Temporal data is mapped onto momentum space in an atomic ensemble, with the spinwave $\mathcal{S}(k)$ capturing the Fourier transform of the input envelope.
• Recall (EIT): The spinwave structure is converted back into a temporal envelope, yielding a direct time-frequency Fourier transform.
• Temporal Double Slit: The coherent recombination of time-separated pulses within memory manifests as interference fringes in the Fourier conjugate domain, with implications for temporal-mode multiplexing and quantum network interfacing.

This brings time-frequency domain manipulations—well established in classical optics—into quantum manipulation contexts, providing tools for entanglement and high-dimensional information encoding.

---

In-mirror Fourier transform techniques thus span a spectrum from classical recursion-based space optimization, digital and analog processing-in-memory accelerators, algebraic and functional transform generalizations, to photonic quantum memories. Their key benefits include dramatically reduced memory footprint (O(1) auxiliary space), data locality and parallelization, optimality within known computational lower bounds, and extensibility to multichannel, multiresolution, or domain-swapping modalities. The mathematical rigor underpinning these approaches—unitarity, convolution diagonalization, uncertainty bounds, group structure—ensures preserved signal fidelity and broad suitability for scaling on contemporary and emerging high-throughput computing architecture.