12 research outputs found
Fast generalized DFTs for all finite groups
For any finite group G, we give an arithmetic algorithm to compute generalized Discrete Fourier Transforms (DFTs) with respect to G, using O(|G|^(ω/2+ ϵ)) operations, for any ϵ > 0. Here, ω is the exponent of matrix multiplication
Fast generalized DFTs for all finite groups
For any finite group , we give an arithmetic algorithm to compute
generalized Discrete Fourier Transforms (DFTs) with respect to , using
operations, for any . Here,
is the exponent of matrix multiplication
Fast generalized DFTs for all finite groups
For any finite group G, we give an arithmetic algorithm to compute generalized Discrete Fourier Transforms (DFTs) with respect to G, using O(|G|^(ω/2+ ϵ)) operations, for any ϵ > 0. Here, ω is the exponent of matrix multiplication
Computing Generalized Convolutions Faster Than Brute Force
In this paper, we consider a general notion of convolution.
Let be a finite domain and let be the set of -length vectors
(tuples) of . Let be a function and
let be a coordinate-wise application of . The -Convolution of two
functions is
\begin{displaymath}
(g \circledast_f h)(v) := \sum_{\substack{v_g,v_h \in
D^n\\ \text{s.t. } v = v_g \oplus_f v_h}} g(v_g) \cdot h(v_h)
\end{displaymath}
for every .
This problem generalizes many fundamental convolutions
such as Subset Convolution, XOR Product, Covering Product or Packing Product,
etc.
For arbitrary function and domain we can compute -Convolution via brute-force enumeration
in time.
Our main result is an improvement over this naive algorithm. We show that -Convolution
can be computed exactly in for constant when has even cardinality. Our main observation is that a
\emph{cyclic partition} of a function can
be used to speed up the computation of -Convolution, and we show that an appropriate
cyclic partition exists for every .
Furthermore, we demonstrate that a single entry of the -Convolution can be computed
more efficiently. In this variant, we are given two functions alongside with a vector and the task of
the -Query problem is to compute integer . This is a
generalization of the well-known Orthogonal Vectors problem. We show that
-Query can be computed in time, where is the exponent of currently fastest matrix multiplication
algorithm
Stronger 3-SUM Lower Bounds for Approximate Distance Oracles via Additive Combinatorics
The "short cycle removal" technique was recently introduced by Abboud,
Bringmann, Khoury and Zamir (STOC '22) to prove fine-grained hardness of
approximation. Its main technical result is that listing all triangles in an
-regular graph is -hard under the 3-SUM conjecture even
when the number of short cycles is small; namely, when the number of -cycles
is for .
Abboud et al. achieve by applying structure vs. randomness
arguments on graphs. In this paper, we take a step back and apply conceptually
similar arguments on the numbers of the 3-SUM problem. Consequently, we achieve
the best possible and the following lower bounds under the 3-SUM
conjecture:
* Approximate distance oracles: The seminal Thorup-Zwick distance oracles
achieve stretch after preprocessing a graph in
time. For the same stretch, and assuming the query time is Abboud et
al. proved an lower bound on the
preprocessing time; we improve it to which is only a
factor 2 away from the upper bound. We also obtain tight bounds for stretch
and and higher lower bounds for dynamic shortest paths.
* Listing 4-cycles: Abboud et al. proved the first super-linear lower bound
for listing all 4-cycles in a graph, ruling out time
algorithms where is the number of 4-cycles. We settle the complexity of
this basic problem by showing that the
upper bound is tight up to factors.
Our results exploit a rich tool set from additive combinatorics, most notably
the Balog-Szemer\'edi-Gowers theorem and Rusza's covering lemma. A key
ingredient that may be of independent interest is a subquadratic algorithm for
3-SUM if one of the sets has small doubling.Comment: Abstract shortened to fit arXiv requirement
Sparse {Fourier Transform} by Traversing {Cooley-Tukey FFT} Computation Graphs
Computing the dominant Fourier coefficients of a vector is a common task in many fields, such as signal processing, learning theory, and computational complexity. In the Sparse Fast Fourier Transform (Sparse FFT) problem, one is given oracle access to a -dimensional vector of size , and is asked to compute the best -term approximation of its Discrete Fourier Transform, quickly and using few samples of the input vector . While the sample complexity of this problem is quite well understood, all previous approaches either suffer from an exponential dependence of runtime on the dimension or can only tolerate a trivial amount of noise. This is in sharp contrast with the classical FFT algorithm of Cooley and Tukey, which is stable and completely insensitive to the dimension of the input vector: its runtime is in any dimension . In this work, we introduce a new high-dimensional Sparse FFT toolkit and use it to obtain new algorithms, both on the exact, as well as in the case of bounded noise. This toolkit includes i) a new strategy for exploring a pruned FFT computation tree that reduces the cost of filtering, ii) new structural properties of adaptive aliasing filters recently introduced by Kapralov, Velingker and Zandieh'SODA'19, and iii) a novel lazy estimation argument, suited to reducing the cost of estimation in FFT tree-traversal approaches. Our robust algorithm can be viewed as a highly optimized sparse, stable extension of the Cooley-Tukey FFT algorithm. Finally, we explain the barriers we have faced by proving a conditional quadratic lower bound on the running time of the well-studied non-equispaced Fourier transform problem. This resolves a natural and frequently asked question in computational Fourier transforms. Lastly, we provide a preliminary experimental evaluation comparing the runtime of our algorithm to FFTW and SFFT 2.0
Traversing the FFT Computation Tree for Dimension-Independent Sparse Fourier Transforms
We consider the well-studied Sparse Fourier transform problem, where one aims
to quickly recover an approximately Fourier -sparse vector from observing its time domain representation . In the
exact -sparse case the best known dimension-independent algorithm runs in
near cubic time in and it is unclear whether a faster algorithm like in low
dimensions is possible. Beyond that, all known approaches either suffer from an
exponential dependence on the dimension or can only tolerate a trivial
amount of noise. This is in sharp contrast with the classical FFT of Cooley and
Tukey, which is stable and completely insensitive to the dimension of the input
vector: its runtime is in any dimension for . Our work
aims to address the above issues.
First, we provide a translation/reduction of the exactly -sparse FT
problem to a concrete tree exploration task which asks to recover leaves in
a full binary tree under certain exploration rules. Subsequently, we provide
(a) an almost quadratic in time algorithm for this task, and (b) evidence
that a strongly subquadratic time for Sparse FT via this approach is likely
impossible. We achieve the latter by proving a conditional quadratic time lower
bound on sparse polynomial multipoint evaluation (the classical non-equispaced
sparse FT) which is a core routine in the aforementioned translation. Thus, our
results combined can be viewed as an almost complete understanding of this
approach, which is the only known approach that yields sublinear time
dimension-independent Sparse FT algorithms.
Subsequently, we provide a robustification of our algorithm, yielding a
robust cubic time algorithm under bounded noise. This requires proving
new structural properties of the recently introduced adaptive aliasing filters
combined with a variety of new techniques and ideas
Algorithms for sparse convolution and sublinear edit distance
In this PhD thesis on fine-grained algorithm design and complexity, we investigate output-sensitive and sublinear-time algorithms for two important problems. (1) Sparse Convolution: Computing the convolution of two vectors is a basic algorithmic primitive with applications across all of Computer Science and Engineering. In the sparse convolution problem we assume that the input and output vectors have at most t nonzero entries, and the goal is to design algorithms with running times dependent on t. For the special case where all entries are nonnegative, which is particularly important for algorithm design, it is known since twenty years that sparse convolutions can be computed in near-linear randomized time O(t log^2 n). In this thesis we develop a randomized algorithm with running time O(t \log t) which is optimal (under some mild assumptions), and the first near-linear deterministic algorithm for sparse nonnegative convolution. We also present an application of these results, leading to seemingly unrelated fine-grained lower bounds against distance oracles in graphs. (2) Sublinear Edit Distance: The edit distance of two strings is a well-studied similarity measure with numerous applications in computational biology. While computing the edit distance exactly provably requires quadratic time, a long line of research has lead to a constant-factor approximation algorithm in almost-linear time. Perhaps surprisingly, it is also possible to approximate the edit distance k within a large factor O(k) in sublinear time O~(n/k + poly(k)). We drastically improve the approximation factor of the known sublinear algorithms from O(k) to k^{o(1)} while preserving the O(n/k + poly(k)) running time.In dieser Doktorarbeit über feinkörnige Algorithmen und Komplexität untersuchen wir ausgabesensitive Algorithmen und Algorithmen mit sublinearer Lauf-zeit für zwei wichtige Probleme. (1) Dünne Faltungen: Die Berechnung der Faltung zweier Vektoren ist ein grundlegendes algorithmisches Primitiv, das in allen Bereichen der Informatik und des Ingenieurwesens Anwendung findet. Für das dünne Faltungsproblem nehmen wir an, dass die Eingabe- und Ausgabevektoren höchstens t Einträge ungleich Null haben, und das Ziel ist, Algorithmen mit Laufzeiten in Abhängigkeit von t zu entwickeln. Für den speziellen Fall, dass alle Einträge nicht-negativ sind, was insbesondere für den Entwurf von Algorithmen relevant ist, ist seit zwanzig Jahren bekannt, dass dünn besetzte Faltungen in nahezu linearer randomisierter Zeit O(t \log^2 n) berechnet werden können. In dieser Arbeit entwickeln wir einen randomisierten Algorithmus mit Laufzeit O(t \log t), der (unter milden Annahmen) optimal ist, und den ersten nahezu linearen deterministischen Algorithmus für dünne nichtnegative Faltungen. Wir stellen auch eine Anwendung dieser Ergebnisse vor, die zu scheinbar unverwandten feinkörnigen unteren Schranken gegen Distanzorakel in Graphen führt. (2) Sublineare Editierdistanz: Die Editierdistanz zweier Zeichenketten ist ein gut untersuchtes Ähnlichkeitsmaß mit zahlreichen Anwendungen in der Computerbiologie. Während die exakte Berechnung der Editierdistanz nachweislich quadratische Zeit erfordert, hat eine lange Reihe von Forschungsarbeiten zu einem Approximationsalgorithmus mit konstantem Faktor in fast-linearer Zeit geführt. Überraschenderweise ist es auch möglich, die Editierdistanz k innerhalb eines großen Faktors O(k) in sublinearer Zeit O~(n/k + poly(k)) zu approximieren. Wir verbessern drastisch den Approximationsfaktor der bekannten sublinearen Algorithmen von O(k) auf k^{o(1)} unter Beibehaltung der O(n/k + poly(k))-Laufzeit