arXiv subjects

Nick Fischer

Publications and source records attributed to Nick Fischer.

At least 19 recordsLinked to original sources

arXiv2026

Real-to-Integer Reduction for All-Pairs Shortest Paths

Efficient graph algorithms often use techniques that are specific to integer-valued inputs and do not work for real-valued versions of the problems. Is it a limitation of current techniques, or are the real-valued variants inherently harder? One way to study this question is through real-to-integer reductions. We give (randomized, combinatorial) subcubic real-to-integer reductions for two central graph problems in fine-grained complexity: All-Pairs Shortest Paths and Exact Triangle. That is, we show that if the integer variants of these problems can be solved in truly subcubic time, then the real variants can also be solved in truly subcubic time. Our work extends and combines techniques from three previous works: (1) our real-to-integer reduction for the 3SUM problem (Fischer, Polak, Schmidt, FOCS 2026), which itself combines the Frank--Tardos theorem from optimization with Freiman's theorem from additive combinatorics; (2) universe reduction for APSP (Fischer, STOC 2026), which we generalize to reals and use to reduce the doubling of the set of edge weights; and (3) the ``Fredman's trick meets dominance product'' technique (Chan, Vassilevska Williams, Xu, STOC 2023), which is needed to adapt the prior real-to-integer framework from equality constraints to inequalities. As a corollary, our reduction combined with Yuval's fast Integer APSP algorithm in the real RAM model with multiplication (IPL 1976) shows that the Real APSP Hypothesis is false in this model, which also follows from the very recent breakthrough by Alman and Vassilevska Williams using a very different approach.

cs.DS↗

arXiv2026

The Hyperclique Hypothesis is False

The Hyperclique Hypothesis postulates that, for all constants $k > h \geq 3$, detecting a $k$-clique in an $h$-uniform hypergraph with $n$ vertices requires time $n^{k-o(1)}$. This hypothesis is false: there is an algebraic algorithm that detects (and even counts) $k$-cliques in $h$-uniform hypergraphs in time $O(n^{(1-ε_h)k})$. Via known reductions, this also refutes the recently proposed $k$-AP Hypothesis. As a consequence, many problems with conditional lower bounds based on these two hypotheses may admit faster algorithms after all. This result is almost entirely due to AI.

cs.DS↗

arXiv2026

Beyond 3SUM-Hardness for Geometric Problems

Since the early days of fine-grained complexity, many geometric problems have been shown to require quadratic time under the 3SUM Hypothesis. But as the 3SUM Hypothesis was recently refuted, these lower bounds have lost their foundation. In this note we point out that many of them can be recovered under an alternative hardness assumption, the $k$-AP Hypothesis. The required changes to the proofs are trivial, so the lower bounds remain just as easy to teach.

cs.DS↗

arXiv2026

Preprocessed 3SUM: From Reals to Integers

The Preprocessed 3SUM problem asks to preprocess a set $A$ of $n$ numbers so that we can quickly decide whether a query subset $A' \subseteq A$ contains a solution $a+b=c$. The best known query bounds differ substantially between integer and real inputs. For integers, a series of advances with near-quadratic preprocessing reduced the query time from $\tilde O(n^{13/7})$ [Chan, Lewenstein; STOC '15] to $\tilde O(n^{11/6})$ [Chan, Vassilevska W., Xu; STOC '23], and finally to $\tilde O(n^{3/2})$ [Kasliwal, Polak, Sharma; SOSA '25]. For reals, only the first of these bounds has been achieved, by adapting the corresponding integer algorithm [Fischer; SODA '25]. Is this gap inherent to the more limited tools available for real inputs? We give a randomized real-to-integer reduction with $\tilde O(n^2)$ preprocessing overhead and no asymptotic increase in query time. This yields $\tilde O(n^2)$ preprocessing and $\tilde O(n^{3/2})$ query time for real inputs, closing the gap. We show how to extend our result to the setting where one set is unknown at preprocessing time. Our reduction is conceptually simple, and relies on an interesting technical toolkit around old and new tools from sparse linear algebra. More broadly, it suggests a route to real-to-integer reductions for other additive problems.

cs.DS↗

arXiv2026

3SUM Is Really Hard: A Real-to-Integer Reduction

We show that if the 3SUM problem on integer-valued inputs can be solved in truly subquadratic time, then it can also be solved in truly subquadratic time on real-valued inputs. This answers an open problem posed by Chan, Vassilevska Williams, and Xu [STOC 2022], and constitutes the first such tight real-to-integer self-reduction in fine-grained complexity. Our proof relies on a surprising combination of the Frank--Tardos theorem from optimization with Freiman-type theorems from additive combinatorics.

cs.DS↗

arXiv2026

Min-Plus Convolution Lower Bounds via a Higher-Order BSG Theorem

Min-Plus Convolution is a central problem in fine-grained complexity, and the associated Min-Plus Convolution Hypothesis forms the basis for a wide range of conditional lower bounds for fundamental problems. It is closely connected to the APSP and 3SUM Hypotheses, and in fact implies both, making it a unifying hypothesis for two of the main pillars of the area. In this work we establish several strong results related to Min-Plus Convolution. We design a universe reduction, showing, under a plausible additive combinatorics assumption, that the Min-Plus Convolution Hypothesis is equivalent to the Strong Min-Plus Convolution Hypothesis. We also obtain tight conditional lower bounds for multiple long-standing problems, including Min-Max Convolution and Bounded Monotone Min-Plus Convolution. Our approach is inspired by Fischer's recent equivalence between several variants of APSP [STOC '26], but extending that technique to the arithmetic setting requires overcoming deep obstacles. To this end, we develop a novel additive structure theorem that can be viewed as a higher-order substitute of the Balog-Szemerédi-Gowers (BSG) theorem, allowing us to extract strong additive structure even from weakly structured sets. Building on this structural result, we show that certain structured 3SUM instances (namely, sets with low rank) can be solved in truly subquadratic time. This algorithm forms the main algorithmic ingredient in our reductions. Besides, it generalizes all previously known truly subquadratic-time special cases of 3SUM, and is therefore of independent interest.

cs.DS↗

arXiv2026

Efficiently Listing Projected Trees, and Equivalence of Listing and Enumeration

The subgraph isomorphism problem and its generalizations, such as conjunctive queries where some nodes are projected, are among the most fundamental problems in graph algorithms and database theory. In this paper, we study the listing and enumeration variants of these problems and present two main results. The first result is an algorithm for enumerating projected trees with preprocessing time $\widetilde{O}(n^{17.42})$ and delay $\mathrm{polylog}(n)$. Prior to this work, for trees on $k$ nodes all algorithms in the literature required preprocessing time $n^{Ω(k)}$ or delay $n^{Ω(1)}$ or assumed $ω=2$. Our result generalizes to arbitrary projected hypergraphs, achieving enumeration in preprocessing time $\widetilde{O}(m^{17.42 \, \mathrm{subw}(H)})$ and polylogarithmic delay, where $\mathrm{subw}(H)$ is the submodular width of the pattern hypergraph $H$. We heavily rely on fast (rectangular and output-sensitive) matrix multiplication, which we complement by fine-grained lower bounds indicating that any algorithm beating preprocessing time $n^{Ω(k)}$ with polylogarithmic delay must rely on fast matrix multiplication. The second result is a generic enumeration-to-listing reduction, establishing that listing and enumeration are equivalent under natural assumptions. For (colored) subgraph isomorphism, our reduction transforms any listing algorithm running in time $O(f(n,m) + t \cdot g(n,m))$ into an enumeration algorithm with preprocessing time $O\left( (f(n,m)+g(n,m)+n+m) \log^2 n \right)$ and delay $O(g(n,m))$. We utilize this reduction to prove our first main result, and we expect that our generic reduction will find many future applications.

cs.DS↗

arXiv2026

A Truly Subcubic Combinatorial Algorithm for Induced 4-Cycle Detection

We present the first truly subcubic, combinatorial algorithm for detecting an induced $4$-cycle in a graph. The running time is $O(n^{2.84})$ on $n$-node graphs, thus separating the task of detecting induced $4$-cycles from detecting triangles, which requires $n^{3-o(1)}$ time combinatorially under the popular BMM hypothesis. Significant work has gone into characterizing the exact time complexity of induced $H$-detection, relative to the complexity of detecting cliques of various sizes. Prior work identified the question of whether induced $4$-cycle detection is triangle-hard as the only remaining case towards completing the lowest level of the classification, dubbing it a "curious" case [Dalirrooyfard, Vassilevska W., FOCS 2022]. Our result can be seen as a negative resolution of this question. Our algorithm deviates from previous techniques in the large body of subgraph detection algorithms and employs the trendy topic of graph decomposition that has hitherto been restricted to more global problems (as in the use of expander decompositions for flow problems) or to shaving subpolynomial factors (as in the application of graph regularity lemmas). While our algorithm is slower than the (non-combinatorial) state-of-the-art $\tilde{O}(n^ω)$-time algorithm based on polynomial identity testing [Vassilevska W., Wang, Williams, Yu, SODA 2014], combinatorial advancements often come with other benefits. In particular, we give the first nontrivial deterministic algorithm for detecting induced $4$-cycles.

cs.DS↗

arXiv2026

Robustifying Sparse Matrix Multiplication

In the seminal sparse matrix multiplication problem the goal is to compute the product of two $n \times n$ matrices when the matrices are sparse, i.e., when the number of nonzeros in the input matrices $m_{in}$ and/or the number of nonzeros in the output matrix $m_{out}$ are much smaller than $n^2$. In this paper, we explore the generalized problem of (approximately) computing the $k$ largest output entries, with an approximation error dependent solely on the smaller entries -- from the viewpoint of sparse recovery, this can be seen as a robust variant of sparse matrix multiplication. Despite the substantial research dedicated to sparse matrix multiplication, almost no existing algorithms are robust in this sense. The one exception is Pagh's algorithm in time $\widetilde O(m_{in} + nk)$ [ITCS'12], and it remained open whether other algorithms can be similarly made robust. Our principal contribution is a black-box reduction from robust sparse matrix multiplication to conventional sparse matrix multiplication with only polylogarithmic overhead. Specifically, we show that any sparse matrix multiplication algorithm with running time $T(n, m_{in}, m_{out})$ can be transformed into a robust algorithm running in time $\widetilde O(T(n, m_{in}, k))$. This reduction leverages an extensive toolkit from sparse recovery, and intriguingly, also involves solving a knapsack-type problem. By plugging in the state-of-the-art algorithm for sparse matrix multiplication by Abboud, Bringmann, Fischer, and Künnemann [SODA'24], we achieve significantly improved bounds such as $O((m_{in} + k)^{1.346})$. Notably, in the regime where $k \geq m_{in}^{1.762}$, our reduction culminates in an almost-optimal $k^{1+o(1)}$-time algorithm.

cs.DS↗

arXiv2026

An Optimal Algorithm for Binary Closest String

We revisit the Binary Closest String problem, which asks, given a set of binary strings $X \subseteq \{0, 1\}^n$, to compute a string minimizing the maximum Hamming distance to $X$. A long line of work has focused on parameterized algorithms with respect to the optimal distance $d$, yielding a sequence of improvements from $O^*(d^d)$ through $O^*(16^d)$, $O^*(9.513^d)$, $O^*(8^d)$, $O^*(6.731^d)$ to the current best-known running time of $O^*(5^d)$ [Chen, Ma, Wang; Algorithmica '16]. We present a faster randomized algorithm running in time $O^*(4^d)$. Our result matches a recent fine-grained lower bound [Abboud, Fischer, Goldenberg, Karthik C.S., Safier; ESA '23], and is therefore conditionally optimal. As an extra benefit, our algorithm is remarkably simple.

cs.DS↗

arXiv2026

Node-Weighted Triangles: Faster and Simpler

Weighted variants of triangle detection are an important object of study because of their prominence in fine-grained complexity. We revisit the Node-Weighted Triangle problem, where the goal is to decide if a vertex-weighted graph contains a triangle whose node weights sum to zero. This problem has been the focus of a celebrated line of work, beginning with a subcubic-time algorithm [Vassilevska, Williams; STOC '06], and culminating in algorithms running almost in matrix multiplication time, $O(\textsf{MM}(n) + n^2\cdot 2^{O(\sqrt{\log n})})$ [Czumaj, Lingas; SODA '07], [Vassilevska W., Williams; STOC '09]. This runtime is almost-optimal, since even detecting an unweighted triangle is conjectured to require matrix multiplication time $\textsf{MM}(n)$. However, the superpolylogarithmic $2^{Ω(\sqrt{\log n})}$ overhead persists in a world where near-optimal matrix multiplication is possible (i.e., $\textsf{MM}(n) \leq n^2\text{poly}(\log n)$). In this paper, we present a new algorithm solving Node-Weighted Triangle in $O(\textsf{MM}(n))$ time, closing the gap to unweighted triangle detection completely. Remarkably, our algorithm is much simpler than previous approaches, which use involved recursion schemes and communication protocols.

cs.DS↗

arXiv2026

Classifying Identities: Subcubic Distributivity Checking and Hardness from Arithmetic Progression Detection

We revisit the complexity of verifying basic identities, such as associativity and distributivity, on a given finite algebraic structure. In particular, while Rajagopalan and Schulman (FOCS'96, SICOMP'00) gave a surprising randomized algorithm to verify associativity of an operation $\odot: S\times S\to S$ in optimal time $O(|S|^2)$, they left the open problem of finding any subcubic algorithm for verifying distributivity of given operations $\odot,\oplus: S\times S\to S$. Our results are as follows: * We resolve the open problem by Rajagopalan and Schulman by devising an algorithm verifying distributivity in strongly subcubic time $O(|S|^ω)$, together with a matching conditional lower bound based on the Triangle Detection Hypothesis. * We propose arithmetic progression detection in small universes as a consequential algorithmic challenge: We show that unless we can detect $4$-term arithmetic progressions in a set $X\subseteq\{1,\dots, N\}$ in time $O(N^{2-ε})$, then (a) the 3-uniform 4-hyperclique hypothesis is true, and (b) verifying certain identities requires running time~$|S|^{3-o(1)}$. * A careful combination of our algorithmic and hardness ideas allows us to \emph{fully classify} a natural subclass of identities: Specifically, any 3-variable identity over binary operations in which no side is a subexpression of the other is either: (1) verifiable in randomized time $O(|S|^2)$, (2) verifiable in randomized time $O(|S|^ω)$ with a matching lower bound from triangle detection, or (3) trivially verifiable in time $O(|S|^3)$ with a matching lower bound from hardness of 4-term arithmetic progression detection. * We obtain near-optimal algorithms for verifying whether a given algebraic structure forms a field or ring, and show that \emph{counting} the number of distributive triples is conditionally harder than verifying distributivity.

cs.DS↗

arXiv2026

Universe Reduction for APSP: Equivalence of Three Fine-Grained Hypotheses

The APSP Hypothesis states that the All-Pairs Shortest Paths (APSP) problem requires time $n^{3-o(1)}$ on graphs with polynomially bounded integer edge weights. Two increasingly stronger assumptions are the Strong APSP Hypothesis and the Directed Unweighted APSP Hypothesis, which state that the fastest-known APSP algorithms on graphs with small weights and unweighted graphs, respectively, are best-possible. In this paper, we design an efficient universe reduction for APSP, which proves that these three hypotheses are, in fact, equivalent, conditioned on $ω= 2$ and a plausible additive combinatorics assumption. Along the way, we resolve the fine-grained complexity of many long-standing graph and matrix problems with "intermediate" complexity such as Node-Weighted APSP, All-Pairs Bottleneck Paths, Monotone Min-Plus Product in certain settings, and many others, by designing matching APSP-based lower bounds.

cs.DS↗

arXiv2026

A Simple Algorithm for Trimmed Multipoint Evaluation

Evaluating a polynomial on a set of points is a fundamental task in computer algebra. In this work, we revisit a particular variant called trimmed multipoint evaluation: given an $n$-variate polynomial with bounded individual degree $d$ and total degree $D$, the goal is to evaluate it on a natural class of input points. This problem arises as a key subroutine in recent algorithmic results [Dinur; SODA '21], [Dell, Haak, Kallmayer, Wennmann; SODA '25]. It is known that trimmed multipoint evaluation can be solved in near-linear time [van der Hoeven, Schost; AAECC '13] by a clever yet somewhat involved algorithm. We give a simple recursive algorithm that avoids heavy computer-algebraic machinery, and can be readily understood by researchers without specialized background.

cs.DS↗

arXiv2026

Conditionally Tight Algorithms for Maximum k-Coverage and Partial k-Dominating Set via Arity-Reducing Hypercuts

We revisit the classic Maximum $k$-Coverage problem: Determine the largest number $t$ of elements that can be covered by choosing $k$ sets from a given family $\mathcal{F} = \{S_1,\dots, S_n\}$ of a size-$u$ universe. A notable special case is Partial $k$-Dominating Set, where one chooses $k$ vertices in a graph to maximize the number of dominated vertices. Extensive research has established strong hardness results for various aspects of Maximum $k$-Coverage, such as tight inapproximability results, $W[2]$-hardness, and a conditionally tight worst-case running time of $n^{k\pm o(1)}$. In this paper we ask: (1) Can this time bound be improved for small $t$, at least for Partial $k$-Dominating Set, ideally to time~$t^{k\pm O(1)}$? (2) More ambitiously, can we even determine the best-possible running time of Maximum $k$-Coverage with respect to the perhaps most natural parameters: the universe size $u$, the maximum set size $s$, and the maximum frequency $f$? We successfully resolve both questions. (1) We give an algorithm that solves Partial $k$-Dominating Set in time $O(nt + t^{\frac{2ω}{3} k+O(1)})$ if $ω\ge 2.25$ and time $O(nt+ t^{\frac{3}{2} k+O(1)})$ if $ω\le 2.25$, where $ω\le 2.372$ is the matrix multiplication exponent. From this we derive a time bound that is conditionally optimal, regardless of $ω$, based on the well-established $k$-clique and 3-uniform hyperclique hypotheses from fine-grained complexity. We also obtain matching upper and lower bounds for sparse graphs. To address (2) we design an algorithm for Maximum $k$-Coverage running in time $$ \min \left\{ (f\cdot \min\{\sqrt[3]{u}, \sqrt{s}\})^k + \min\{n,f\cdot \min\{\sqrt{u}, s\}\}^{kω/3}, n^k\right\} \cdot g(k)n^{\pm O(1)}, $$ and, surprisingly, further show that this complicated time bound is also conditionally optimal.

cs.DS↗

arXiv2025

Separations between Oblivious and Adaptive Adversaries for Natural Dynamic Graph Problems

We establish the first update-time separation between dynamic algorithms against oblivious adversaries and those against adaptive adversaries in natural dynamic graph problems, based on popular fine-grained complexity hypotheses. Specifically, under the combinatorial BMM hypothesis, we show that every combinatorial algorithm against an adaptive adversary for the incremental maximal independent set problem requires $n^{1-o(1)}$ amortized update time. Furthermore, assuming either the 3SUM or APSP hypotheses, every algorithm for the decremental maximal clique problem needs $Δ/n^{o(1)}$ amortized update time when the initial maximum degree is $Δ\le \sqrt{n}$. These lower bounds are matched by existing algorithms against adaptive adversaries. In contrast, both problems admit algorithms against oblivious adversaries that achieve $\operatorname{polylog}(n)$ amortized update time [Behnezhad, Derakhshan, Hajiaghayi, Stein, Sudan; FOCS '19] [Chechik, Zhang; FOCS '19]. Therefore, our separations are exponential. Previously known separations for dynamic algorithms were either engineered for contrived problems and relied on strong cryptographic assumptions [Beimel, Kaplan, Mansour, Nissim, Saranurak, Stemmer; STOC '22], or worked for problems whose inputs are not explicitly given but are accessed through oracle calls [Bateni, Esfandiari, Fichtenberger, Henzinger, Jayaram, Mirrokni, Wiese; SODA '23]. As a byproduct, we also provide a separation between incremental and decremental algorithms for the triangle detection problem: we show a decremental algorithm with $\tilde{O}(n^ω)$ total update time, while every incremental algorithm requires $n^{3-o(1)}$ total update time, assuming the OMv hypothesis. To our knowledge this is the first separation of this kind.

cs.DS↗

arXiv2025

$\ell_2/\ell_2$ Sparse Recovery via Weighted Hypergraph Peeling

We demonstrate that the best $k$-sparse approximation of a length-$n$ vector can be recovered within a $(1+ε)$-factor approximation in $O((k/ε) \log n)$ time using a non-adaptive linear sketch with $O((k/ε) \log n)$ rows and $O(\log n)$ column sparsity. This improves the running time of the fastest-known sketch [Nakos, Song; STOC '19] by a factor of $\log n$, and is optimal for a wide range of parameters. Our algorithm is simple and likely to be practical, with the analysis built on a new technique we call weighted hypergraph peeling. Our method naturally extends known hypergraph peeling processes (as in the analysis of Invertible Bloom Filters) to a setting where edges and nodes have (possibly correlated) weights.

cs.DS↗

arXiv2025

Minimizing Tardy Processing Time on a Single Machine in Near-Linear Time

In this work we revisit the elementary scheduling problem $1||\sum p_j U_j$. The goal is to select, among $n$ jobs with processing times and due dates, a subset of jobs with maximum total processing time that can be scheduled in sequence without violating their due dates. This problem is NP-hard, but a classical algorithm by Lawler and Moore from the 60s solves this problem in pseudo-polynomial time $O(nP)$, where $P$ is the total processing time of all jobs. With the aim to develop best-possible pseudo-polynomial-time algorithms, a recent wave of results has improved Lawler and Moore's algorithm for $1||\sum p_j U_j$: First to time $\tilde O(P^{7/4})$ [Bringmann, Fischer, Hermelin, Shabtay, Wellnitz; ICALP'20], then to time $\tilde O(P^{5/3})$ [Klein, Polak, Rohwedder; SODA'23], and finally to time $\tilde O(P^{7/5})$ [Schieber, Sitaraman; WADS'23]. It remained an exciting open question whether these works can be improved further. In this work we develop an algorithm in near-linear time $\tilde O(P)$ for the $1||\sum p_j U_j$ problem. This running time not only significantly improves upon the previous results, but also matches conditional lower bounds based on the Strong Exponential Time Hypothesis or the Set Cover Hypothesis and is therefore likely optimal (up to subpolynomial factors). Our new algorithm also extends to the case of $m$ machines in time $\tilde O(P^m)$. In contrast to the previous improvements, we take a different, more direct approach inspired by the recent reductions from Modular Subset Sum to dynamic string problems. We thereby arrive at a satisfyingly simple algorithm.

cs.DS↗