Last Update

OPML feed of all feeds.

Subscribe to the Atom feed, RSS feed to stay up to date.

Thank you to arXiv for use of its open access interoperability.

Note: the date of arXiv entries announced right after publication holidays might incorrectly show up as the date of the publication holiday itself. This is due to our ad hoc method of inferring announcement dates, which are not returned by the arXiv API.

Powered by Pluto.

Source on GitHub.

Maintained by Nima Anari, Arnab Bhattacharyya, Gautam Kamath.

Theory of Computing Report

Tuesday, November 17

Postdoctoral position at the University of Technology Sydney node of the ARC Centre of Excellence MathQuEST at University of Technology Sydney (apply by December 10, 2026)

from CCI: jobs

A 2-year postdoctoral position is available at the University of Technology Sydney, contributing to the Australian Research Council (ARC) Centre of Excellence in Mathematics for Quantum Era Security & Trust (MathQuEST). We welcome candidates in theoretical computer science, cryptography or mathematics, with a focus on quantum aspects of these areas. Website: recruitment.uts.edu.au/OA_HTML/OA.jsp?OAFunc=IRC_VIS_VAC_DISPLAY&p_svid=350083&p_spid=14714792&bid=2609&tid=x_9f768180-e84f-4835-8edb-694f20f54366&utm_source=2609 Email: Youming.Qiao@uts.edu.au

A 2-year postdoctoral position is available at the University of Technology Sydney, contributing to the Australian Research Council (ARC) Centre of Excellence in Mathematics for Quantum Era Security & Trust (MathQuEST). We welcome candidates in theoretical computer science, cryptography or mathematics, with a focus on quantum aspects of these areas.

Website: https://recruitment.uts.edu.au/OA_HTML/OA.jsp?OAFunc=IRC_VIS_VAC_DISPLAY&p_svid=350083&p_spid=14714792&bid=2609&tid=x_9f768180-e84f-4835-8edb-694f20f54366&utm_source=2609
Email: Youming.Qiao@uts.edu.au

By shacharlovett

Möbius-Pseudorandomness for Algebraic Circuits

from arXiv: Computational Complexity

Authors: Gil Kalai, Mrinal Kumar, Ben Lee Volk

We define a notion of Möbius-pseudorandomness for integer sequences generated by multivariate polynomials computed by small and simple algebraic circuits. This mirrors a related definition of Kalai that concerns boolean functions computed by small boolean circuits. We then prove Möbius-pseudorandomness results for polynomials computed by algebraic circuits with few multiplication gates (of any depth), for polynomials with small-dimensional partial derivative space, and for the determinant and permanent. We conjecture that these results hold in general for polynomial-size algebraic circuits.

Authors: Gil Kalai, Mrinal Kumar, Ben Lee Volk

We define a notion of Möbius-pseudorandomness for integer sequences generated by multivariate polynomials computed by small and simple algebraic circuits. This mirrors a related definition of Kalai that concerns boolean functions computed by small boolean circuits. We then prove Möbius-pseudorandomness results for polynomials computed by algebraic circuits with few multiplication gates (of any depth), for polynomials with small-dimensional partial derivative space, and for the determinant and permanent. We conjecture that these results hold in general for polynomial-size algebraic circuits.

Separations Between Randomized and Exact Quantum Query Complexity for Boolean Functions

from arXiv: Computational Complexity

Authors: Zekun Ye

We construct a family of total Boolean functions $F_{\mathrm{tot}}$ whose randomized and exact quantum query complexities satisfy $R(F_{\mathrm{tot}}) \ge Q_E(F_{\mathrm{tot}})^{2-o(1)}$. Chiruvella, Kayal, Mittal, Paraashar, and Saurabh (2026) also obtained a nearly quadratic separation for total functions in the query model by a different method. For every fixed $\varepsilon \in (0,1)$, we construct a family of partial Boolean functions $F_{\mathrm{par}}$ on $n$ bits satisfying $Q_E(F_{\mathrm{par}})=O_\varepsilon(1)$ and $R(F_{\mathrm{par}})=Ω_\varepsilon(n^{1-\varepsilon})$. This matches the asymptotic separation previously obtained with bounded error (STOC 2021; SICOMP 2023). Lifting yields a family of partial communication functions $G_{\mathrm{par}}$ with $Q_E^{\mathrm{cc}}(G_{\mathrm{par}})=O_\varepsilon(\log n)$ and $R^{\mathrm{pub,cc}}(G_{\mathrm{par}})=Ω_\varepsilon(n^{1-\varepsilon})$, where $n$ is the total number of input bits held by the two parties.

Authors: Zekun Ye

We construct a family of total Boolean functions $F_{\mathrm{tot}}$ whose randomized and exact quantum query complexities satisfy $R(F_{\mathrm{tot}}) \ge Q_E(F_{\mathrm{tot}})^{2-o(1)}$. Chiruvella, Kayal, Mittal, Paraashar, and Saurabh (2026) also obtained a nearly quadratic separation for total functions in the query model by a different method. For every fixed $\varepsilon \in (0,1)$, we construct a family of partial Boolean functions $F_{\mathrm{par}}$ on $n$ bits satisfying $Q_E(F_{\mathrm{par}})=O_\varepsilon(1)$ and $R(F_{\mathrm{par}})=Ω_\varepsilon(n^{1-\varepsilon})$. This matches the asymptotic separation previously obtained with bounded error (STOC 2021; SICOMP 2023). Lifting yields a family of partial communication functions $G_{\mathrm{par}}$ with $Q_E^{\mathrm{cc}}(G_{\mathrm{par}})=O_\varepsilon(\log n)$ and $R^{\mathrm{pub,cc}}(G_{\mathrm{par}})=Ω_\varepsilon(n^{1-\varepsilon})$, where $n$ is the total number of input bits held by the two parties.

How Can Size, Ceiling, and Time Bounds Affect the Complexity of Nonuniform Automata Families?

from arXiv: Computational Complexity

Authors: Tomoyuki Yamakami

In the past literature, families of two-way finite automata and pushdown automata having limited resource-bounded complexity have been studied in direct connection to (mainstream) space-bounded complexity classes equipped with Karp-Lipton style advice of limited size when all inputs given to the automata have bounded length. We acknowledge three major factors--size, ceiling, and time--of such families, which have a significant impact on the computational/descriptional complexity of finite and pushdown automata families, where the "size" refers to the (stack-)state complexity, the "ceiling" refers to the maximum input length, and the "time" refers to the execution time of underlying automata. In this line of study, we further explore these effects caused by different sizes and ceilings. We exploit automata-based reducibility and translatability to space-bounded advised Turing machines and auxiliary automata.

Authors: Tomoyuki Yamakami

In the past literature, families of two-way finite automata and pushdown automata having limited resource-bounded complexity have been studied in direct connection to (mainstream) space-bounded complexity classes equipped with Karp-Lipton style advice of limited size when all inputs given to the automata have bounded length. We acknowledge three major factors--size, ceiling, and time--of such families, which have a significant impact on the computational/descriptional complexity of finite and pushdown automata families, where the "size" refers to the (stack-)state complexity, the "ceiling" refers to the maximum input length, and the "time" refers to the execution time of underlying automata. In this line of study, we further explore these effects caused by different sizes and ceilings. We exploit automata-based reducibility and translatability to space-bounded advised Turing machines and auxiliary automata.

Nearly Settling the Complexity of Connected $\varepsilon$-Envy-Free Cake Cutting

from arXiv: Computational Complexity

Authors: Simon Mackenzie, Mashbat Suzuki

Envy-free cake cutting has been one of the central problems in fair division. In cake cutting, agents' preferences over the cake are accessed through Robertson--Webb (RW) queries. For three or more agents, no algorithm that makes finitely many RW queries can always find a contiguous, exactly envy-free allocation. For contiguous $\varepsilon$-envy-free allocations, however, Hollender and Rubinstein~(JACM, 2025) showed that $\poly(\log(1/\varepsilon))$ RW queries suffice for four agents, leaving open whether such a bound is possible for five or more agents. In this paper, we establish a striking change in query complexity: $\poly(\log(1/\varepsilon))$ RW queries suffice for up to five agents, whereas $(1/\varepsilon)^{Ω(1)}$ queries are necessary for seven or more agents, even when valuations are additive. Thus, we resolve the five-agent case and, more broadly, determine whether polylogarithmic query complexity is possible for every number of agents except six. We also explore the computational complexity of finding contiguous $\varepsilon$-envy-free allocations. When monotone Lipschitz valuations are given by polynomial-time evaluation procedures (e.g., arithmetic circuits and efficiently computable Turing machines), we show that an $\varepsilon$-envy-free division can be computed in polynomial time for five agents. In contrast, even for additive valuations, finding an $\varepsilon$-envy-free division is UEOPL-hard for every fixed number of agents $n\ge7$ and PPAD-complete for every fixed $n\ge13$.

Authors: Simon Mackenzie, Mashbat Suzuki

Envy-free cake cutting has been one of the central problems in fair division. In cake cutting, agents' preferences over the cake are accessed through Robertson--Webb (RW) queries. For three or more agents, no algorithm that makes finitely many RW queries can always find a contiguous, exactly envy-free allocation. For contiguous $\varepsilon$-envy-free allocations, however, Hollender and Rubinstein~(JACM, 2025) showed that $\poly(\log(1/\varepsilon))$ RW queries suffice for four agents, leaving open whether such a bound is possible for five or more agents. In this paper, we establish a striking change in query complexity: $\poly(\log(1/\varepsilon))$ RW queries suffice for up to five agents, whereas $(1/\varepsilon)^{Ω(1)}$ queries are necessary for seven or more agents, even when valuations are additive. Thus, we resolve the five-agent case and, more broadly, determine whether polylogarithmic query complexity is possible for every number of agents except six. We also explore the computational complexity of finding contiguous $\varepsilon$-envy-free allocations. When monotone Lipschitz valuations are given by polynomial-time evaluation procedures (e.g., arithmetic circuits and efficiently computable Turing machines), we show that an $\varepsilon$-envy-free division can be computed in polynomial time for five agents. In contrast, even for additive valuations, finding an $\varepsilon$-envy-free division is UEOPL-hard for every fixed number of agents $n\ge7$ and PPAD-complete for every fixed $n\ge13$.

Postselection on Halting and Reductions to the Halting Problem

from arXiv: Computational Complexity

Authors: Saman Farhat, Farzad Didehvar

A probabilistic Turing machine is an ordinary Turing machine that may also toss fair coins, with no limit on its running time or memory. If it always halts, it decides only computable problems. Aaronson et al. studied machines that may run forever on some coin tosses, with the answer read only from the runs that halt. Suppose the correct answer must be more than twice as likely as the wrong one. They showed that these machines decide exactly the problems solvable with a fixed list of questions about the halting problem. They asked what happens when the correct answer need only be the more likely one. We show that the machines then decide exactly the problems solvable by asking such questions one after another, each chosen after the earlier answers. We also show that the factor two can be replaced by any fixed factor greater than one. A machine may promise two numbers: a lower bound on its probability of halting, and a lower bound on its probability of being right when it halts. From these two numbers we compute exactly how many questions fixed in advance the machine can replace. The main idea is that probability acts as a budget for how often a computable guess may change its mind. The results extend to oracle machines and to machines nested inside each other. Quantum machines decide the same problems.

Authors: Saman Farhat, Farzad Didehvar

A probabilistic Turing machine is an ordinary Turing machine that may also toss fair coins, with no limit on its running time or memory. If it always halts, it decides only computable problems. Aaronson et al. studied machines that may run forever on some coin tosses, with the answer read only from the runs that halt. Suppose the correct answer must be more than twice as likely as the wrong one. They showed that these machines decide exactly the problems solvable with a fixed list of questions about the halting problem. They asked what happens when the correct answer need only be the more likely one. We show that the machines then decide exactly the problems solvable by asking such questions one after another, each chosen after the earlier answers. We also show that the factor two can be replaced by any fixed factor greater than one. A machine may promise two numbers: a lower bound on its probability of halting, and a lower bound on its probability of being right when it halts. From these two numbers we compute exactly how many questions fixed in advance the machine can replace. The main idea is that probability acts as a budget for how often a computable guess may change its mind. The results extend to oracle machines and to machines nested inside each other. Quantum machines decide the same problems.

Independent set reconfiguration is hard at treewidth four

from arXiv: Computational Complexity

Authors: Hussein Abbas, Haydar Hamieh, Amer E. Mouawad, Ali Slim

Independent Set Reconfiguration asks whether one of two given independent sets of equal size can be transformed into the other by moving one token at a time while keeping the occupied vertices independent. In token sliding, a token moves along an edge. In token jumping, it may move to any unoccupied vertex. For both rules, the problem is solvable in polynomial time on trees and is PSPACE-complete on graphs of treewidth at most $c$ for some fixed constant $c$. For each rule, the smallest treewidth bound that suffices for hardness has long been open. We narrow this gap by proving that both versions are NP-hard on graphs of treewidth four.

Authors: Hussein Abbas, Haydar Hamieh, Amer E. Mouawad, Ali Slim

Independent Set Reconfiguration asks whether one of two given independent sets of equal size can be transformed into the other by moving one token at a time while keeping the occupied vertices independent. In token sliding, a token moves along an edge. In token jumping, it may move to any unoccupied vertex. For both rules, the problem is solvable in polynomial time on trees and is PSPACE-complete on graphs of treewidth at most $c$ for some fixed constant $c$. For each rule, the smallest treewidth bound that suffices for hardness has long been open. We narrow this gap by proving that both versions are NP-hard on graphs of treewidth four.

Planar PArcK is PSPACE-complete

from arXiv: Computational Complexity

Authors: Craig Tennenhouse, Kanae Yoshiwatari

Partizan Arc Kayles, or PArcK, is a partizan combinatorial game on edge colored graphs, and is a generalization of the game Domineering. Previously, PArcK was shown to be PSPACE-complete on bipartite graphs. In this paper we show that PArcK is PSPACE-complete even when restricted to planar graphs of degree at most three by a reduction from Generalized Hex.

Authors: Craig Tennenhouse, Kanae Yoshiwatari

Partizan Arc Kayles, or PArcK, is a partizan combinatorial game on edge colored graphs, and is a generalization of the game Domineering. Previously, PArcK was shown to be PSPACE-complete on bipartite graphs. In this paper we show that PArcK is PSPACE-complete even when restricted to planar graphs of degree at most three by a reduction from Generalized Hex.

Who Observes Whom: Network Rationalizability and Its Complexity

from arXiv: Computational Complexity

Authors: Mojtaba Fayaz-Bakhsh, MohammadAmin Fazli

Nash equilibrium and rationalizability sit at opposite informational extremes: the former presumes that each player knows all opponents' strategies, the latter that players reason from common knowledge of rationality alone. When visibility is partial and asymmetric, we study the solution concepts induced by a directed \emph{observation network} $G$ in which an edge $i\to j$ means that $i$ observes $j$'s strategy. A set of profiles is \emph{self-sustaining} if every profile in it can be justified, for every player, by conjectures from the same set that agree with everything the player observes. We consider \emph{point} conjectures (single profiles) and \emph{belief} conjectures (distributions over profiles). Both range from Nash equilibrium on the complete network to point- and correlated rationalizability on the empty network, and shrink monotonically as links are added. Network topology governs both behavior and complexity. A predicted profile can be found in polynomial time on the empty network, whereas a single link makes search $\mathsf{PPAD}$-hard: under one-sided two-player monitoring, the observed player's strategies are exactly her Nash equilibrium strategies. On hierarchical networks (transitive tournaments), membership reduces recursively to smaller games and admits polynomial-size certificates, placing verification in $\exists\mathbb{R}$, and in $\mathsf{P}$ for two players. On the directed three-cycle, however, iterated elimination may never terminate under either variant, and under point conjectures interior predictions may admit only infinite witness sets, a pathology that belief conjectures avoid in the same game. Finally, when only realized pure actions are observed, the solution set is guaranteed to be non-empty exactly when the network has no edges, and is computable in time $O(n|A|^2)$.

Authors: Mojtaba Fayaz-Bakhsh, MohammadAmin Fazli

Nash equilibrium and rationalizability sit at opposite informational extremes: the former presumes that each player knows all opponents' strategies, the latter that players reason from common knowledge of rationality alone. When visibility is partial and asymmetric, we study the solution concepts induced by a directed \emph{observation network} $G$ in which an edge $i\to j$ means that $i$ observes $j$'s strategy. A set of profiles is \emph{self-sustaining} if every profile in it can be justified, for every player, by conjectures from the same set that agree with everything the player observes. We consider \emph{point} conjectures (single profiles) and \emph{belief} conjectures (distributions over profiles). Both range from Nash equilibrium on the complete network to point- and correlated rationalizability on the empty network, and shrink monotonically as links are added. Network topology governs both behavior and complexity. A predicted profile can be found in polynomial time on the empty network, whereas a single link makes search $\mathsf{PPAD}$-hard: under one-sided two-player monitoring, the observed player's strategies are exactly her Nash equilibrium strategies. On hierarchical networks (transitive tournaments), membership reduces recursively to smaller games and admits polynomial-size certificates, placing verification in $\exists\mathbb{R}$, and in $\mathsf{P}$ for two players. On the directed three-cycle, however, iterated elimination may never terminate under either variant, and under point conjectures interior predictions may admit only infinite witness sets, a pathology that belief conjectures avoid in the same game. Finally, when only realized pure actions are observed, the solution set is guaranteed to be non-empty exactly when the network has no edges, and is computable in time $O(n|A|^2)$.

Towards Understanding the Complexity of CAQE: A Proof-Theoretic Analysis of its Core Procedure

from arXiv: Computational Complexity

Authors: Benjamin Böhm, Olaf Beyersdorff

CAQE (Clausal Abstraction for Quantifier Elimination) is currently the most successful algorithmic paradigm for solving Quantified Boolean Formulas (QBF) in practice, clearly dominating recent QBF competitions. While apparently being a very strong solver, not much is known about CAQE in theory. We propose a framework for formalising runs of the basic CAQE algorithm (where failed assumptions are not considered) as proofs in a proof system CAQE$^{\mathsf{Core}}$, which we use to analyse the algorithm proof-theoretically and which provides methods for future work to separate it from optimised versions of CAQE that are used in practice. We show that one can perform strategy extraction on the CAQE$^{\mathsf{Core}}$ proof system in such a way that strategy size serves as a lower bound for basic CAQE runs. Furthermore, we introduce a measure, which we call CAQE width, which not only acts as a lower bound on CAQE$^{\mathsf{Core}}$ proofs, but -- with the number of $\exists\forall$ alternations as exponent -- as an upper bound as well. Using this analysis, we prove that Q-resolution with an NP oracle simulates CAQE$^{\mathsf{Core}}$ on QCNFs of bounded quantifier alternation. The same holds for QCDCL (Quantified Conflict-Driven Clause Learning, formalised as a proof system) on $Σ_3^b$ QCNFs when purely propositional CDCL steps are not counted, after a simple preprocessing step. In this setting, both systems are indeed strictly stronger than CAQE$^{\mathsf{Core}}$, where the separation of QCDCL from CAQE$^{\mathsf{Core}}$ uses cube learning.

Authors: Benjamin Böhm, Olaf Beyersdorff

CAQE (Clausal Abstraction for Quantifier Elimination) is currently the most successful algorithmic paradigm for solving Quantified Boolean Formulas (QBF) in practice, clearly dominating recent QBF competitions. While apparently being a very strong solver, not much is known about CAQE in theory. We propose a framework for formalising runs of the basic CAQE algorithm (where failed assumptions are not considered) as proofs in a proof system CAQE$^{\mathsf{Core}}$, which we use to analyse the algorithm proof-theoretically and which provides methods for future work to separate it from optimised versions of CAQE that are used in practice. We show that one can perform strategy extraction on the CAQE$^{\mathsf{Core}}$ proof system in such a way that strategy size serves as a lower bound for basic CAQE runs. Furthermore, we introduce a measure, which we call CAQE width, which not only acts as a lower bound on CAQE$^{\mathsf{Core}}$ proofs, but -- with the number of $\exists\forall$ alternations as exponent -- as an upper bound as well. Using this analysis, we prove that Q-resolution with an NP oracle simulates CAQE$^{\mathsf{Core}}$ on QCNFs of bounded quantifier alternation. The same holds for QCDCL (Quantified Conflict-Driven Clause Learning, formalised as a proof system) on $Σ_3^b$ QCNFs when purely propositional CDCL steps are not counted, after a simple preprocessing step. In this setting, both systems are indeed strictly stronger than CAQE$^{\mathsf{Core}}$, where the separation of QCDCL from CAQE$^{\mathsf{Core}}$ uses cube learning.

Hyperlyve: Parallelized Enumeration and Exact Lyapunov Stability Certification for Deep ReLU Networks

from arXiv: Computational Geometry

Authors: Brian Yarbrough, Jesse Wayment, Jingbo Wang, Philip E. Paré, Shreyas Sundaram

We introduce Hyperlyve (Hyperplane Partitioned Lyapunov Verification and Enumeration), a framework for proving the asymptotic stability of nonlinear dynamical systems, including those with neural network controllers. Hyperlyve learns and formally certifies continuous piecewise-affine (CPA) neural Lyapunov functions within a counterexample-guided inductive synthesis (CEGIS) loop. Hyperlyve's key innovation is a parallel algorithm that enumerates the hyperplane arrangement formed by the ReLU activations of deep networks and certifies that Lyapunov conditions hold within each polyhedral region. We derive sound and complete regional tests to verify the asymptotic stability of the exact smooth dynamics (rather than a piecewise-linear approximation) within a compact domain of interest. Furthermore, we formally characterize the computational complexity of the CPA neural Lyapunov verification problem as co-NP-complete, filling a key gap in the literature. Empirical results demonstrate that Hyperlyve enumerates ReLU networks over 150-times faster than competing tools, which contributes to Hyperlyve proving the asymptotic stability of systems that are currently intractable for state-of-the-art verifiers.

Authors: Brian Yarbrough, Jesse Wayment, Jingbo Wang, Philip E. Paré, Shreyas Sundaram

We introduce Hyperlyve (Hyperplane Partitioned Lyapunov Verification and Enumeration), a framework for proving the asymptotic stability of nonlinear dynamical systems, including those with neural network controllers. Hyperlyve learns and formally certifies continuous piecewise-affine (CPA) neural Lyapunov functions within a counterexample-guided inductive synthesis (CEGIS) loop. Hyperlyve's key innovation is a parallel algorithm that enumerates the hyperplane arrangement formed by the ReLU activations of deep networks and certifies that Lyapunov conditions hold within each polyhedral region. We derive sound and complete regional tests to verify the asymptotic stability of the exact smooth dynamics (rather than a piecewise-linear approximation) within a compact domain of interest. Furthermore, we formally characterize the computational complexity of the CPA neural Lyapunov verification problem as co-NP-complete, filling a key gap in the literature. Empirical results demonstrate that Hyperlyve enumerates ReLU networks over 150-times faster than competing tools, which contributes to Hyperlyve proving the asymptotic stability of systems that are currently intractable for state-of-the-art verifiers.

A Polynomial-Time Algorithm for Maximum Witness Set

from arXiv: Computational Geometry

Authors: Satyabrata Jana, Debabrata Pal, Sasanka Roy

A witness set in a polygon is a set of points whose visibility regions are pairwise disjoint. Since no point of the polygon can see more than one witness, the cardinality of a witness set provides a lower bound on the minimum number of guards required to cover the polygon. Finding a maximum witness set is therefore a natural packing counterpart to the classical Art Gallery problem. While the latter is $\exists\mathbb{R}$-complete, the computational complexity of finding a maximum witness set in a general simple polygon has remained open. In this paper, we present a polynomial-time algorithm for computing a maximum witness set in a simple polygon with $n$ vertices, of which $ρ$ are reflex, assuming that no three vertices are collinear. Our algorithm runs in $\mathcal{O}(ρ^4n^6\log n)$ time. Our approach exploits a tree structure induced by witness visibility regions and employs geometric dynamic programming over nested regions determined by visibility windows.

Authors: Satyabrata Jana, Debabrata Pal, Sasanka Roy

A witness set in a polygon is a set of points whose visibility regions are pairwise disjoint. Since no point of the polygon can see more than one witness, the cardinality of a witness set provides a lower bound on the minimum number of guards required to cover the polygon. Finding a maximum witness set is therefore a natural packing counterpart to the classical Art Gallery problem. While the latter is $\exists\mathbb{R}$-complete, the computational complexity of finding a maximum witness set in a general simple polygon has remained open. In this paper, we present a polynomial-time algorithm for computing a maximum witness set in a simple polygon with $n$ vertices, of which $ρ$ are reflex, assuming that no three vertices are collinear. Our algorithm runs in $\mathcal{O}(ρ^4n^6\log n)$ time. Our approach exploits a tree structure induced by witness visibility regions and employs geometric dynamic programming over nested regions determined by visibility windows.

Polynomial bounds for quasiplanar graphs

from arXiv: Computational Geometry

Authors: Aleksa Milojević, Patryk Morawski, Benny Sudakov, Istvan Tomon

A graph $G$ is $k$-quasiplanar if it can be drawn in the plane without $k$ pairwise crossing edges. It was a longstanding conjecture that $n$-vertex $k$-quasiplanar graphs have $O_k(n)$ edges. This was recently resolved by Sadhu and, independently, by Pach, Tardos, and Zeng, based on a theorem in topology proven by Beeker and Lazarovich. These papers showed that $k$-quasiplanar graphs have at most $k^{O(k)}n$ edges. In this note, we greatly improve the dependence on $k$ and show that every $k$-quasiplanar $n$-vertex graph has at most $O(k^2n)$ edges. The proof is based on a geometric charging scheme and Erdős-Szekeres type combinatorial arguments.

Authors: Aleksa Milojević, Patryk Morawski, Benny Sudakov, Istvan Tomon

A graph $G$ is $k$-quasiplanar if it can be drawn in the plane without $k$ pairwise crossing edges. It was a longstanding conjecture that $n$-vertex $k$-quasiplanar graphs have $O_k(n)$ edges. This was recently resolved by Sadhu and, independently, by Pach, Tardos, and Zeng, based on a theorem in topology proven by Beeker and Lazarovich. These papers showed that $k$-quasiplanar graphs have at most $k^{O(k)}n$ edges. In this note, we greatly improve the dependence on $k$ and show that every $k$-quasiplanar $n$-vertex graph has at most $O(k^2n)$ edges. The proof is based on a geometric charging scheme and Erdős-Szekeres type combinatorial arguments.

Hierarchical Regime-Conditioned Dynamics for Spatiotemporal Graphs

from arXiv: Computational Geometry

Authors: Jeremy Baffou, Pascal Frossard, Dorina Thanou

Forecasting the behavior of spatio-temporal systems often requires more than accurate predictions: models should uncover the dynamical modes governing future evolution. Existing temporal graph and latent dynamical models achieve strong forecasting performance, but their latent representations often entangle multiple dynamical patterns, limiting interpretability. Conversely, regime-inference methods explicitly model such modes but typically do not support generative forecasting over graph-structured systems. We introduce HERON, a self-supervised regime-aware generative framework that unifies graph-structured trajectory generation with regime identification. HERON factorizes the latent state into discrete system-level regimes, capturing global dynamical modes, and continuous entity-level dynamics, yielding a modular regime interface compatible with existing spatio-temporal backbones. Crucially, the inferred regime actively conditions system dynamics, enabling regime tracking and controlled simulations under alternative dynamical modes. Without regime annotations, HERON jointly learns forecasts and regime dynamics in a self-supervised manner, recovering meaningful modes across controlled synthetic and real-world datasets while maintaining competitive forecasting performance. These results open a path toward interpretable, controllable generative modeling of spatio-temporal dynamics.

Authors: Jeremy Baffou, Pascal Frossard, Dorina Thanou

Forecasting the behavior of spatio-temporal systems often requires more than accurate predictions: models should uncover the dynamical modes governing future evolution. Existing temporal graph and latent dynamical models achieve strong forecasting performance, but their latent representations often entangle multiple dynamical patterns, limiting interpretability. Conversely, regime-inference methods explicitly model such modes but typically do not support generative forecasting over graph-structured systems. We introduce HERON, a self-supervised regime-aware generative framework that unifies graph-structured trajectory generation with regime identification. HERON factorizes the latent state into discrete system-level regimes, capturing global dynamical modes, and continuous entity-level dynamics, yielding a modular regime interface compatible with existing spatio-temporal backbones. Crucially, the inferred regime actively conditions system dynamics, enabling regime tracking and controlled simulations under alternative dynamical modes. Without regime annotations, HERON jointly learns forecasts and regime dynamics in a self-supervised manner, recovering meaningful modes across controlled synthetic and real-world datasets while maintaining competitive forecasting performance. These results open a path toward interpretable, controllable generative modeling of spatio-temporal dynamics.

The Deepest Pairs of Points Are Not as Deep as Conjectured

from arXiv: Computational Geometry

Authors: Herbert Edelsbrunner, Alexey Garber, Morteza Saghafian, Emo Welzl

Given any finite set of points in $\mathbb{R}^2$, Neumann-Lara and Urrutia \cite{NLUr88} proved in 1988 that there is always a pair such that every circle through the two points encloses a positive fraction of all points. While Edelsbrunner et al.\ \cite{EHSS89} showed that the fraction is at least $\sfrac{1}{2} - \sfrac{1}{\sqrt{12}} = 0.211\ldots$, Urrutia \cite{Urr02} conjectured that the constant $\sfrac{1}{4} = 0.25$ in the upper bound proved by Hayward, Rappaport and Wenger \cite{HRW89} is best possible. We disprove this conjecture by lowering the constant to $\sfrac{3}{14} = 0.214\ldots$. The new bound also disproves a related conjecture by Ramos and Viaña \cite{RaVi09} on finite sets in convex position in $\mathbb{R}^3$. Finally, we generalize the latter extremal question to finite sets in possibly non-convex position, for which we prove the first linear lower bound, with constant $\sfrac{(2-\sqrt{2})}{6} = 0.097\ldots$.

Authors: Herbert Edelsbrunner, Alexey Garber, Morteza Saghafian, Emo Welzl

Given any finite set of points in $\mathbb{R}^2$, Neumann-Lara and Urrutia \cite{NLUr88} proved in 1988 that there is always a pair such that every circle through the two points encloses a positive fraction of all points. While Edelsbrunner et al.\ \cite{EHSS89} showed that the fraction is at least $\sfrac{1}{2} - \sfrac{1}{\sqrt{12}} = 0.211\ldots$, Urrutia \cite{Urr02} conjectured that the constant $\sfrac{1}{4} = 0.25$ in the upper bound proved by Hayward, Rappaport and Wenger \cite{HRW89} is best possible. We disprove this conjecture by lowering the constant to $\sfrac{3}{14} = 0.214\ldots$. The new bound also disproves a related conjecture by Ramos and Viaña \cite{RaVi09} on finite sets in convex position in $\mathbb{R}^3$. Finally, we generalize the latter extremal question to finite sets in possibly non-convex position, for which we prove the first linear lower bound, with constant $\sfrac{(2-\sqrt{2})}{6} = 0.097\ldots$.

Impatience Makes Matching NP-Hard

from arXiv: Data Structures and Algorithms

Authors: Chen Yan, Sushil Mahavir Varma

Motivated by emerging applications such as online marketplaces and quantum switches, we study a dynamic bipartite matching model with impatient agents, where the two sides represent customers and suppliers. Agents of each type arrive according to an independent Poisson process, and the platform decides which pairs of agents to match. The agents are possibly impatient and may leave the system if not matched before their patience expires. The platform aims to maximize throughput, i.e., the number of matches per unit time. In this paper, we reveal an interesting phase transition in the computational hardness of throughput maximization. In particular, we show that approximating the optimal long-run throughput within a sufficiently small fixed relative error is NP-hard, even when all agents have rate-one exponential patience. This result implies a computational barrier to constructing near-optimal, efficiently executable matching policies that induce a matching process with fast mixing. On the other hand, when all agents on at least one side have infinite patience, we provide a simple polynomial-time algorithm that maximizes the throughput.

Authors: Chen Yan, Sushil Mahavir Varma

Motivated by emerging applications such as online marketplaces and quantum switches, we study a dynamic bipartite matching model with impatient agents, where the two sides represent customers and suppliers. Agents of each type arrive according to an independent Poisson process, and the platform decides which pairs of agents to match. The agents are possibly impatient and may leave the system if not matched before their patience expires. The platform aims to maximize throughput, i.e., the number of matches per unit time. In this paper, we reveal an interesting phase transition in the computational hardness of throughput maximization. In particular, we show that approximating the optimal long-run throughput within a sufficiently small fixed relative error is NP-hard, even when all agents have rate-one exponential patience. This result implies a computational barrier to constructing near-optimal, efficiently executable matching policies that induce a matching process with fast mixing. On the other hand, when all agents on at least one side have infinite patience, we provide a simple polynomial-time algorithm that maximizes the throughput.

When is Uniform Sampling Optimal? Coresets for Distributional Clustering

from arXiv: Data Structures and Algorithms

Authors: Junqiu Hu, Lingxiao Huang, Baoduo Xu

Recent work [1] settled the optimal worst-case strong $\varepsilon$-coreset size for Euclidean $k$-means in unrestricted dimension at $\tildeΘ(\min\{k^{3/2}\varepsilon^{-2}, k\varepsilon^{-4}\})$, showing that the natural target $\tilde{O}(k\varepsilon^{-2})$ is unattainable in general. For mixtures of $k$ isotropic Gaussian components with balanced weights and bounded scale imbalance in dimension $d\ge\log k$, we show that uniform sampling yields strong $\varepsilon$-coresets of size $\tilde{O}(k\varepsilon^{-2})$, without cluster separation. This saves a factor of $\min\{\sqrt{k},\varepsilon^{-2}\}$ over the worst-case bound, up to logarithms. For population approximation by independent, equally weighted samples, the near-linear rate is optimal up to logarithmic factors over this class. More generally, for datasets generated from an isotropic Gaussian mixture $μ$ satisfying a mild cost-comparison assumption, uniform sampling yields strong $\varepsilon$-coresets of size $\tilde{O}((kζ_μ+π_{\min}^{-1})\varepsilon^{-2})$, where $π_{\min}$ is the minimum component weight and $ζ_μ$ measures scale imbalance. Our proof uses a base-shift cost decomposition: one query center per component describes the base costs, and graph spanners control the sparse corrections from points switching centers. For general mixtures under cost and tail assumptions, we obtain $\tilde{O}((kζ_μ+π_{\min}^{-1})\varepsilon^{-2}\min\{\sqrt{k},\varepsilon^{-2}\})$ samples. We also prove a matching $\tildeΩ(\min\{k^{3/2}\varepsilon^{-2},k\varepsilon^{-4}\})$ lower bound for population approximation by uniform sampling from anisotropic Gaussian mixtures, even with equal weights and a shared covariance matrix. [1] Junqiu Hu, Lingxiao Huang, Jian Li, and Baoduo Xu. Tight coreset bounds for $(k, z)$-clustering in Euclidean and doubling metrics, 2026. arXiv:2610.34373.

Authors: Junqiu Hu, Lingxiao Huang, Baoduo Xu

Recent work [1] settled the optimal worst-case strong $\varepsilon$-coreset size for Euclidean $k$-means in unrestricted dimension at $\tildeΘ(\min\{k^{3/2}\varepsilon^{-2}, k\varepsilon^{-4}\})$, showing that the natural target $\tilde{O}(k\varepsilon^{-2})$ is unattainable in general. For mixtures of $k$ isotropic Gaussian components with balanced weights and bounded scale imbalance in dimension $d\ge\log k$, we show that uniform sampling yields strong $\varepsilon$-coresets of size $\tilde{O}(k\varepsilon^{-2})$, without cluster separation. This saves a factor of $\min\{\sqrt{k},\varepsilon^{-2}\}$ over the worst-case bound, up to logarithms. For population approximation by independent, equally weighted samples, the near-linear rate is optimal up to logarithmic factors over this class. More generally, for datasets generated from an isotropic Gaussian mixture $μ$ satisfying a mild cost-comparison assumption, uniform sampling yields strong $\varepsilon$-coresets of size $\tilde{O}((kζ_μ+π_{\min}^{-1})\varepsilon^{-2})$, where $π_{\min}$ is the minimum component weight and $ζ_μ$ measures scale imbalance. Our proof uses a base-shift cost decomposition: one query center per component describes the base costs, and graph spanners control the sparse corrections from points switching centers. For general mixtures under cost and tail assumptions, we obtain $\tilde{O}((kζ_μ+π_{\min}^{-1})\varepsilon^{-2}\min\{\sqrt{k},\varepsilon^{-2}\})$ samples. We also prove a matching $\tildeΩ(\min\{k^{3/2}\varepsilon^{-2},k\varepsilon^{-4}\})$ lower bound for population approximation by uniform sampling from anisotropic Gaussian mixtures, even with equal weights and a shared covariance matrix. [1] Junqiu Hu, Lingxiao Huang, Jian Li, and Baoduo Xu. Tight coreset bounds for $(k, z)$-clustering in Euclidean and doubling metrics, 2026. arXiv:2610.34373.

Computing Independent Sets of Size Three in Disk Graphs

from arXiv: Data Structures and Algorithms

Authors: Anastasiia Tkachenko, Haitao Wang

We study the problem of computing an independent set of size three in disk graphs, where vertices correspond to disks in the plane and two vertices are adjacent if their disks intersect. While computing a maximum independent set in disk graphs is NP-hard, the fixed-size case admits more efficient solutions. Given a set of $n$ disks, we present an algorithm to compute an independent set of size three in the disk graph and our algorithm runs in randomized expected $O^*(n^{5/3})$ time, where $O^*$ hides a factor of $n^ε$ for an arbitrarily small $ε> 0$. Our approach introduces a framework based on semi-algebraic range searching and tree-structured biclique partitions, which allows us to group pairs of disjoint disks into canonical subsets and avoid redundant computations. When the centers of the disks are in convex position, we solve the problem in $O(n \log^2 n)$ deterministic time. We also consider the case in which the disks themselves are in convex position, i.e., each disk contributes to the boundary of the convex hull of all disks, and obtain an $O(n \log^2 n)$ time algorithm for this setting as well. Our techniques for these cases are based on geometric properties of disk arrangements. In particular, they rely on new structural lemmas that reduce the problem to efficiently testing certain ordered configurations of disks. Our results improve upon the straightforward quadratic time approach and demonstrate how geometric structures and range searching techniques can be leveraged to solve fixed-size independent set problems in disk graphs more efficiently. To the best of our knowledge, this is the first systematic study of independent sets of size three in disk graphs. Our results show that even this smallest nontrivial case exhibits rich structural properties, especially under convexity assumptions.

Authors: Anastasiia Tkachenko, Haitao Wang

We study the problem of computing an independent set of size three in disk graphs, where vertices correspond to disks in the plane and two vertices are adjacent if their disks intersect. While computing a maximum independent set in disk graphs is NP-hard, the fixed-size case admits more efficient solutions. Given a set of $n$ disks, we present an algorithm to compute an independent set of size three in the disk graph and our algorithm runs in randomized expected $O^*(n^{5/3})$ time, where $O^*$ hides a factor of $n^ε$ for an arbitrarily small $ε> 0$. Our approach introduces a framework based on semi-algebraic range searching and tree-structured biclique partitions, which allows us to group pairs of disjoint disks into canonical subsets and avoid redundant computations. When the centers of the disks are in convex position, we solve the problem in $O(n \log^2 n)$ deterministic time. We also consider the case in which the disks themselves are in convex position, i.e., each disk contributes to the boundary of the convex hull of all disks, and obtain an $O(n \log^2 n)$ time algorithm for this setting as well. Our techniques for these cases are based on geometric properties of disk arrangements. In particular, they rely on new structural lemmas that reduce the problem to efficiently testing certain ordered configurations of disks. Our results improve upon the straightforward quadratic time approach and demonstrate how geometric structures and range searching techniques can be leveraged to solve fixed-size independent set problems in disk graphs more efficiently. To the best of our knowledge, this is the first systematic study of independent sets of size three in disk graphs. Our results show that even this smallest nontrivial case exhibits rich structural properties, especially under convexity assumptions.

Reducing Asymmetric Path TSP to Asymmetric TSP

from arXiv: Data Structures and Algorithms

Authors: Hong Li

In the Asymmetric Traveling Salesman Problem (Asymmetric TSP), we are given distances between $n$ vertices that satisfy the triangle inequality but need not be symmetric, and we seek a shortest tour through all vertices. In its path version, Asymmetric Path TSP, two vertices $s$ and $t$ are prescribed, and we seek a shortest path from $s$ to $t$ through all vertices. Both problems are equivalent to their versions with arbitrary nonnegative edge costs on a directed graph, in which vertices may be visited more than once. We show that for all constants $α\ge1$ and $\varepsilon>0$, any $α$-approximation algorithm for Asymmetric TSP yields an $(α+\varepsilon)$-approximation algorithm for Asymmetric Path TSP. The best previous reduction of this kind, due to Feige and Singh, yields an $α(2+\varepsilon)$-approximation algorithm. Our result answers an open question of Traub and Vygen. Consequently, every constant-factor approximation guarantee for Asymmetric TSP carries over to Asymmetric Path TSP up to an arbitrarily small additive error.

Authors: Hong Li

In the Asymmetric Traveling Salesman Problem (Asymmetric TSP), we are given distances between $n$ vertices that satisfy the triangle inequality but need not be symmetric, and we seek a shortest tour through all vertices. In its path version, Asymmetric Path TSP, two vertices $s$ and $t$ are prescribed, and we seek a shortest path from $s$ to $t$ through all vertices. Both problems are equivalent to their versions with arbitrary nonnegative edge costs on a directed graph, in which vertices may be visited more than once. We show that for all constants $α\ge1$ and $\varepsilon>0$, any $α$-approximation algorithm for Asymmetric TSP yields an $(α+\varepsilon)$-approximation algorithm for Asymmetric Path TSP. The best previous reduction of this kind, due to Feige and Singh, yields an $α(2+\varepsilon)$-approximation algorithm. Our result answers an open question of Traub and Vygen. Consequently, every constant-factor approximation guarantee for Asymmetric TSP carries over to Asymmetric Path TSP up to an arbitrarily small additive error.

Constant-Factor Matching-Size Estimation in Random-Order Streams

from arXiv: Data Structures and Algorithms

Authors: Alireza Farhadi, Mohammad Hajiaghayi, Morteza Monemizadeh

We give a one-pass algorithm that estimates the maximum matching size of an arbitrary simple graph within a constant factor using $O(\log^2 n)$ bits of space. The edges arrive exactly once in uniformly random order. The algorithm succeeds with probability at least $2/3$, does not require the number of edges in advance, and has worst-case total running time $O((m+1)\log(n+2))$ on a word RAM. Kapralov, Khanna, and Sudan (SODA 2014) obtained a polylogarithmic approximation in polylogarithmic space. Kapralov, Mitrović, Norouzi-Fard, and Tardos (SODA 2020) subsequently gave a constant-factor approximation from independent uniform edge samples and an $O(\log^2 n)$-approximation in random order. We obtain a constant factor in the latter model with the same $O(\log^2 n)$ space bound. The main ingredient is a comparison between the memory states of a recursive sampling algorithm under sampling with and without replacement. We account jointly for the sampled edges retained by the recursion and the positions at which they arrived. Randomized thresholds limit the additional information stored in numerical counters. A bound on the expected work of the entire recursion then removes the loss from its logarithmic depth. The resulting estimator repeatedly improves a coarse estimate while storing only one recursion stack.

Authors: Alireza Farhadi, Mohammad Hajiaghayi, Morteza Monemizadeh

We give a one-pass algorithm that estimates the maximum matching size of an arbitrary simple graph within a constant factor using $O(\log^2 n)$ bits of space. The edges arrive exactly once in uniformly random order. The algorithm succeeds with probability at least $2/3$, does not require the number of edges in advance, and has worst-case total running time $O((m+1)\log(n+2))$ on a word RAM. Kapralov, Khanna, and Sudan (SODA 2014) obtained a polylogarithmic approximation in polylogarithmic space. Kapralov, Mitrović, Norouzi-Fard, and Tardos (SODA 2020) subsequently gave a constant-factor approximation from independent uniform edge samples and an $O(\log^2 n)$-approximation in random order. We obtain a constant factor in the latter model with the same $O(\log^2 n)$ space bound. The main ingredient is a comparison between the memory states of a recursive sampling algorithm under sampling with and without replacement. We account jointly for the sampled edges retained by the recursion and the positions at which they arrived. Randomized thresholds limit the additional information stored in numerical counters. A bound on the expected work of the entire recursion then removes the loss from its logarithmic depth. The resulting estimator repeatedly improves a coarse estimate while storing only one recursion stack.

Odd faces as a parameter for maximum independent set in embedded graphs

from arXiv: Data Structures and Algorithms

Authors: Samuel Fiorini, Stefan Kober, Caleb McFarland

We give a polynomial-time algorithm for finding a maximum weight independent set in a graph embedded in a surface of bounded genus and with a bounded number of vertex-disjoint odd faces. In particular, we obtain an algorithm for graphs with an even-faced embedding in a torus and for planar graphs with a bounded number of odd faces, answering a question of Thomassé (2018) and a question of Choi, Gorsky, Kim, McFarland, and Wiederrecht (2025) respectively. We reduce the original problem to finding a minimum cost non-negative integer circulation with homology constraints in the dual of a certain double cover of the original graph.

Authors: Samuel Fiorini, Stefan Kober, Caleb McFarland

We give a polynomial-time algorithm for finding a maximum weight independent set in a graph embedded in a surface of bounded genus and with a bounded number of vertex-disjoint odd faces. In particular, we obtain an algorithm for graphs with an even-faced embedding in a torus and for planar graphs with a bounded number of odd faces, answering a question of Thomassé (2018) and a question of Choi, Gorsky, Kim, McFarland, and Wiederrecht (2025) respectively. We reduce the original problem to finding a minimum cost non-negative integer circulation with homology constraints in the dual of a certain double cover of the original graph.

A Polynomial Time Algorithm for Finding a Minimum 5-Partition of a Submodular Function

from arXiv: Data Structures and Algorithms

Authors: Yuhao Liu, Ke Shi, Chao Xu

Given a real-valued submodular function on a finite ground set, the minimum $k$-partition problem asks for a partition into $k$ nonempty parts minimizing the sum of their function values. We give a polynomial-time algorithm for $k=5$. The idea follows directly from the previous $k=4$ result, where there is precisely one obstruction for generalizing it to $k=5$. We show the special case can be handled by reasoning about a restricted family of $3$-partitions.

Authors: Yuhao Liu, Ke Shi, Chao Xu

Given a real-valued submodular function on a finite ground set, the minimum $k$-partition problem asks for a partition into $k$ nonempty parts minimizing the sum of their function values. We give a polynomial-time algorithm for $k=5$. The idea follows directly from the previous $k=4$ result, where there is precisely one obstruction for generalizing it to $k=5$. We show the special case can be handled by reasoning about a restricted family of $3$-partitions.

An Optimal Online Algorithm for Single-machine Scheduling with Two Agents

from arXiv: Data Structures and Algorithms

Authors: Peihai Liu, Kejun Zhao, Xiwen Lu

This paper addresses the online two-agent scheduling problem on a single machine, where jobs arrive over time. The objective is to minimize the weighted sum of the agents' makespans, denoted as $C_{\max}^A + θC_{\max}^B$, for a given priority weight $θ\ge 1$. A significant gap has persisted between the established theoretical lower bound on the competitive ratio and the performance of the best-known online algorithms. For the parameter range $1 \leq θ\leq \tfrac{1+\sqrt{5}}{2}$, we propose novel online algorithm which achieves a competitive ratio of $1+\tfracθ{1+θ}$. This result matches the theoretical lower bound.

Authors: Peihai Liu, Kejun Zhao, Xiwen Lu

This paper addresses the online two-agent scheduling problem on a single machine, where jobs arrive over time. The objective is to minimize the weighted sum of the agents' makespans, denoted as $C_{\max}^A + θC_{\max}^B$, for a given priority weight $θ\ge 1$. A significant gap has persisted between the established theoretical lower bound on the competitive ratio and the performance of the best-known online algorithms. For the parameter range $1 \leq θ\leq \tfrac{1+\sqrt{5}}{2}$, we propose novel online algorithm which achieves a competitive ratio of $1+\tfracθ{1+θ}$. This result matches the theoretical lower bound.

Path-constrained Packing on Trees

from arXiv: Data Structures and Algorithms

Authors: Samuel Fiorini, Raoul Luqué, Philipp Pabst, Britta Peis

An instance of Budgeted Path-constrained Packing on Trees (BPPT) consists of a graph $G$ together with a spanning tree $T$, a weight $w_e \in \mathbb{Z}_{\ge 0}$ for each tree edge $e \in E(T)$ and a budget $b_f \in \mathbb{Z}_{\ge 1}$ for each non-tree edge $f \in E(G) \setminus E(T)$. The goal is to find a maximum weight packing of fundamental cuts respecting the budgets. Equivalently, an instance of BPPT is an integer program of the form $\max \{w^\intercal x : Ax \le b,\ x \in \{0,1\}^n\}$ where $A \in \{0,1\}^{m \times n}$ is a transposed edge-path-tree matrix, $w \in \mathbb{Z}^n_{\ge 0}$ and $b \in \mathbb{Z}^m_{\ge 1}$. We define the congestion $C$ of a BPPT instance as the maximum number of non-zeros in a column of $A$. The unit congestion $UC$ is defined similarly, except that rows with $b_i \ge 2$ are ignored. We also consider the minimum budget $β:= \min \{b_i : i = 1, \ldots, m\}$. In this paper, we begin the study of BPPT through the lens of the three parameters $C$, $UC$ and $β$, and relative to the standard LP relaxation $\max \{w^\intercal x : Ax \le b,\ x \in [0,1]^n\}$. BPPT generalizes the independent set problem in graphs of maximum degree at most $C$ and is a special case of the $b$-matching problem in hypergraphs of rank at most $C$. We obtain approximation algorithms for BPPT with factors $2+UC/2$, $1+C/2$ and $β/(β-1)$ for $β\geq 2$. These bounds are relative to the standard LP relaxation and, as we show, integrality gap tight with respect to parameters $UC$ and $β$, and almost integrality gap tight relative to $C$. We complement these results with a $\lceil (C+1)/3 \rceil$-approximation for fixed $C$ which is not relative to the standard LP relaxation and has $\textsf{XP}$ running time parameterized by $C$.

Authors: Samuel Fiorini, Raoul Luqué, Philipp Pabst, Britta Peis

An instance of Budgeted Path-constrained Packing on Trees (BPPT) consists of a graph $G$ together with a spanning tree $T$, a weight $w_e \in \mathbb{Z}_{\ge 0}$ for each tree edge $e \in E(T)$ and a budget $b_f \in \mathbb{Z}_{\ge 1}$ for each non-tree edge $f \in E(G) \setminus E(T)$. The goal is to find a maximum weight packing of fundamental cuts respecting the budgets. Equivalently, an instance of BPPT is an integer program of the form $\max \{w^\intercal x : Ax \le b,\ x \in \{0,1\}^n\}$ where $A \in \{0,1\}^{m \times n}$ is a transposed edge-path-tree matrix, $w \in \mathbb{Z}^n_{\ge 0}$ and $b \in \mathbb{Z}^m_{\ge 1}$. We define the congestion $C$ of a BPPT instance as the maximum number of non-zeros in a column of $A$. The unit congestion $UC$ is defined similarly, except that rows with $b_i \ge 2$ are ignored. We also consider the minimum budget $β:= \min \{b_i : i = 1, \ldots, m\}$. In this paper, we begin the study of BPPT through the lens of the three parameters $C$, $UC$ and $β$, and relative to the standard LP relaxation $\max \{w^\intercal x : Ax \le b,\ x \in [0,1]^n\}$. BPPT generalizes the independent set problem in graphs of maximum degree at most $C$ and is a special case of the $b$-matching problem in hypergraphs of rank at most $C$. We obtain approximation algorithms for BPPT with factors $2+UC/2$, $1+C/2$ and $β/(β-1)$ for $β\geq 2$. These bounds are relative to the standard LP relaxation and, as we show, integrality gap tight with respect to parameters $UC$ and $β$, and almost integrality gap tight relative to $C$. We complement these results with a $\lceil (C+1)/3 \rceil$-approximation for fixed $C$ which is not relative to the standard LP relaxation and has $\textsf{XP}$ running time parameterized by $C$.

Subexponential algorithms for structural parameterizations of Vertex Cover in geometric graphs

from arXiv: Data Structures and Algorithms

Authors: Marin Bougeret, Juan Pablo Bravo, Daniel Gonçalves

A number of recent works have investigated the existence of parameterized subexponential algorithms in geometric graph classes for hitting a fixed small graph as a subgraph or as a minor. In this setting, given an $n$-vertex graph, the goal is to decide in time $n^{O(1)}2^{o(k)}$ if a solution of size at most $k$ exists. Inspired by recent results in kernelization for structural parameters, we investigate subexponential algorithms for the Vertex Cover (VC) problem, but parameterized by distance-to-triviality instead of solution size. More formally, given a fixed "trivial" graph class $\mathcal{C}$, the problem takes as input $(G,X,k)$, where $G \setminus X \in \mathcal{C}$, and asks if $G$ admits a vertex cover of size at most $k$. Our goal is to design algorithms for this problem running in time $n^{O(1)}2^{o(|X|)}$. The motivation is that, since $|X|$ is typically arbitrarily smaller than $k$, such algorithms might be faster than ETH-tight subexponential algorithms parameterized by $k$. We identify two sets of sufficient conditions under which the problem admits a subexponential algorithm: one for the case where $\mathcal{C}$ is the class of paths, and another for the case where $\mathcal{C}$ is the class of graphs of constant treedepth. We also provide two applications of these algorithmic results: we prove that $s$-string graphs and pseudo-disk graphs satisfy the first set of conditions, whereas string graphs satisfy the second set. The two sets share a common condition that might be of independent interest, as it implies a property that bounds the treewidth of any string graph in terms of a given modulator to a fixed graph class $\mathcal{C}$. Finally, concerning more restricted graph classes having the $ASQGM(ω)$ property (such as map graphs and $H$-minor free graphs), we prove a dichotomy, depending on the maximum treewidth in $\mathcal{C}$.

Authors: Marin Bougeret, Juan Pablo Bravo, Daniel Gonçalves

A number of recent works have investigated the existence of parameterized subexponential algorithms in geometric graph classes for hitting a fixed small graph as a subgraph or as a minor. In this setting, given an $n$-vertex graph, the goal is to decide in time $n^{O(1)}2^{o(k)}$ if a solution of size at most $k$ exists. Inspired by recent results in kernelization for structural parameters, we investigate subexponential algorithms for the Vertex Cover (VC) problem, but parameterized by distance-to-triviality instead of solution size. More formally, given a fixed "trivial" graph class $\mathcal{C}$, the problem takes as input $(G,X,k)$, where $G \setminus X \in \mathcal{C}$, and asks if $G$ admits a vertex cover of size at most $k$. Our goal is to design algorithms for this problem running in time $n^{O(1)}2^{o(|X|)}$. The motivation is that, since $|X|$ is typically arbitrarily smaller than $k$, such algorithms might be faster than ETH-tight subexponential algorithms parameterized by $k$. We identify two sets of sufficient conditions under which the problem admits a subexponential algorithm: one for the case where $\mathcal{C}$ is the class of paths, and another for the case where $\mathcal{C}$ is the class of graphs of constant treedepth. We also provide two applications of these algorithmic results: we prove that $s$-string graphs and pseudo-disk graphs satisfy the first set of conditions, whereas string graphs satisfy the second set. The two sets share a common condition that might be of independent interest, as it implies a property that bounds the treewidth of any string graph in terms of a given modulator to a fixed graph class $\mathcal{C}$. Finally, concerning more restricted graph classes having the $ASQGM(ω)$ property (such as map graphs and $H$-minor free graphs), we prove a dichotomy, depending on the maximum treewidth in $\mathcal{C}$.

Copying along Arithmetic Progressions Cannot Simulate Interleaving with Polylogarithmic Loss

from arXiv: Data Structures and Algorithms

Authors: Matthias G. Mayer

Two classical ways to compress a word are straight-line programs (SLPs), which build it by concatenating smaller pieces, and the Lempel-Ziv 77 (LZ77) factorisation, which copies earlier parts of it; their sizes are measures of repetitiveness. LZ77 approximates the smallest SLP efficiently: it has no more factors than a smallest SLP has size, and yields an SLP at most a logarithmic factor larger in near-linear time. Motivated by online prediction, Kosoy introduced zipline programs, which are analogous to SLPs but interleave their pieces round-robin instead of concatenating them. Her generalisation of LZ77, the arithmetic repetition system, describes a word by copies from one arithmetic progression of positions to a later one. Do arithmetic repetition systems approximate the smallest zipline program as well? Kosoy proved that the least size $\mathrm{ARC}(x)$ of an arithmetic repetition system for a word $x$ of length $n$ is at most a factor $O(n^{1/3})$ larger than the least size $\mathrm{ZLC}(x)$ of a zipline program for it, and asked whether this factor is tight. Her polynomial-time next-letter predictor makes $O(\mathrm{ARC}(x)\log n)$ mistakes, so a polylogarithmic factor would bound its mistakes by $\mathrm{ZLC}(x)\,\mathrm{polylog}(n)$, which no known polynomial-time predictor achieves. We show that the optimal exponent is $1/4$, not $1/3$: $\mathrm{ARC}(x) \le 2n^{1/4}\,\mathrm{ZLC}(x)$ for every word $x$, and at every large enough length $n$ some binary word has $\mathrm{ARC}(x) \ge n^{1/4-o(1)}\,\mathrm{ZLC}(x)$.

Authors: Matthias G. Mayer

Two classical ways to compress a word are straight-line programs (SLPs), which build it by concatenating smaller pieces, and the Lempel-Ziv 77 (LZ77) factorisation, which copies earlier parts of it; their sizes are measures of repetitiveness. LZ77 approximates the smallest SLP efficiently: it has no more factors than a smallest SLP has size, and yields an SLP at most a logarithmic factor larger in near-linear time. Motivated by online prediction, Kosoy introduced zipline programs, which are analogous to SLPs but interleave their pieces round-robin instead of concatenating them. Her generalisation of LZ77, the arithmetic repetition system, describes a word by copies from one arithmetic progression of positions to a later one. Do arithmetic repetition systems approximate the smallest zipline program as well? Kosoy proved that the least size $\mathrm{ARC}(x)$ of an arithmetic repetition system for a word $x$ of length $n$ is at most a factor $O(n^{1/3})$ larger than the least size $\mathrm{ZLC}(x)$ of a zipline program for it, and asked whether this factor is tight. Her polynomial-time next-letter predictor makes $O(\mathrm{ARC}(x)\log n)$ mistakes, so a polylogarithmic factor would bound its mistakes by $\mathrm{ZLC}(x)\,\mathrm{polylog}(n)$, which no known polynomial-time predictor achieves. We show that the optimal exponent is $1/4$, not $1/3$: $\mathrm{ARC}(x) \le 2n^{1/4}\,\mathrm{ZLC}(x)$ for every word $x$, and at every large enough length $n$ some binary word has $\mathrm{ARC}(x) \ge n^{1/4-o(1)}\,\mathrm{ZLC}(x)$.

Speed-Robust Scheduling for Total Completion Time

from arXiv: Data Structures and Algorithms

Authors: Moritz Buchem, Nicole Megow, Morten Weber

We study two-stage speed-robust scheduling for minimizing total completion time. Jobs must be partitioned into $M$ bags before an adversary reveals the speeds of at most $M$ machines. Each bag is then assigned to one available machine, and the jobs on each machine may be processed in any order independent of the bags. We compare with an optimal schedule that knows the speeds in advance and assigns jobs individually. This model has been studied for makespan minimization. We initiate its study for total completion time, as suggested by Stein and Zhong (TALG 2020). For an unknown number of identical machines, we show that the optimal deterministic robustness factor is exactly~$13/12$, both for unit-size jobs and for arbitrary processing times. For infinitesimally small jobs, the factor lies between $31/30\approx1.0333$ and $28/27\approx1.0370$, well below the optimal makespan factor of about $1.2071$. General speeds make the problem strictly harder: no deterministic algorithm is better than $1.2669$-robust, already for infinitesimally small jobs. We give a $25/16$-robust algorithm for arbitrary processing times and improve the guarantee to $1681/1152\approx1.4592$ for infinitesimally small jobs. Our main tools are a layer decomposition that extends guarantees from unit-size jobs to arbitrary processing times when one assignment satisfies them for every prefix in non-increasing processing-time order, and a threshold analysis of the bag counts produced by greedy assignment rules.

Authors: Moritz Buchem, Nicole Megow, Morten Weber

We study two-stage speed-robust scheduling for minimizing total completion time. Jobs must be partitioned into $M$ bags before an adversary reveals the speeds of at most $M$ machines. Each bag is then assigned to one available machine, and the jobs on each machine may be processed in any order independent of the bags. We compare with an optimal schedule that knows the speeds in advance and assigns jobs individually. This model has been studied for makespan minimization. We initiate its study for total completion time, as suggested by Stein and Zhong (TALG 2020). For an unknown number of identical machines, we show that the optimal deterministic robustness factor is exactly~$13/12$, both for unit-size jobs and for arbitrary processing times. For infinitesimally small jobs, the factor lies between $31/30\approx1.0333$ and $28/27\approx1.0370$, well below the optimal makespan factor of about $1.2071$. General speeds make the problem strictly harder: no deterministic algorithm is better than $1.2669$-robust, already for infinitesimally small jobs. We give a $25/16$-robust algorithm for arbitrary processing times and improve the guarantee to $1681/1152\approx1.4592$ for infinitesimally small jobs. Our main tools are a layer decomposition that extends guarantees from unit-size jobs to arbitrary processing times when one assignment satisfies them for every prefix in non-increasing processing-time order, and a threshold analysis of the bag counts produced by greedy assignment rules.

Improved Approximation for Weighted $k$-Set Packing via a Simple Two-Phase Approach

from arXiv: Data Structures and Algorithms

Authors: Mehrshad Taziki, Rico Zenklusen

Weighted $k$-set packing asks for a maximum-weight collection of pairwise disjoint sets, each of cardinality at most $k$. For every fixed $k\in\mathbb Z_{\geq1}$, we give a polynomial-time algorithm with approximation factor $\left(1- 1/{\sqrt3} \right)k+O(\log k) \approx 0.4226k + O(\log k)$, improving the previous best factor of $0.4621k + O(\sqrt{k})$ through a simple two-phase approach. In a first phase, our algorithm constructs a packing by processing random weight buckets of varying widths with an unweighted packing algorithm. We show that a small expected weight of this packing relative to the optimum forces a large expected total surplus in the optimum. Surplus quantifies the potential for improving a packing through star swaps. In the second phase, we solve and round a configuration LP to turn sufficiently large surplus into an increase in expected weight. Our procedure can easily be derandomized.

Authors: Mehrshad Taziki, Rico Zenklusen

Weighted $k$-set packing asks for a maximum-weight collection of pairwise disjoint sets, each of cardinality at most $k$. For every fixed $k\in\mathbb Z_{\geq1}$, we give a polynomial-time algorithm with approximation factor $\left(1- 1/{\sqrt3} \right)k+O(\log k) \approx 0.4226k + O(\log k)$, improving the previous best factor of $0.4621k + O(\sqrt{k})$ through a simple two-phase approach. In a first phase, our algorithm constructs a packing by processing random weight buckets of varying widths with an unweighted packing algorithm. We show that a small expected weight of this packing relative to the optimum forces a large expected total surplus in the optimum. Surplus quantifies the potential for improving a packing through star swaps. In the second phase, we solve and round a configuration LP to turn sufficiently large surplus into an increase in expected weight. Our procedure can easily be derandomized.

Rounded Potentials Certify Exact Maximum Flow

from arXiv: Data Structures and Algorithms

Authors: Ohad Trabelsi

The textbook certificate for maximum flow is lopsided: the cut takes one bit per vertex, while the flow takes one number per edge. Indeed, some graphs have $Θ(n^2)$ terminal pairs for which every maximum flow uses $Θ(n^2)$ edges. Yet we show that one short number per vertex suffices for both cut and flow: $n$ vertex potentials, each rounded to $O(\log(nW))$ bits, certify the exact maximum $st$-flow value in any directed graph with integer capacities at most $W$. Exact potentials can have exponentially large representations. Rounding them may violate flow conservation, but the total error across any cut is less than one unit, so integrality of cut capacities absorbs it. Checking conservation is local and linear in the capacities, allowing the same certificate to yield new bounds in four models (capacities are polynomially bounded unless stated otherwise): - Online annotated streaming. $\widetilde{O}(n)$ total cost (help plus space) for the maximum $st$-flow value, optimal up to logarithmic factors, answering a question of Thaler (ICALP 2016) on whether $o(n^2)$ is possible. - Broadcast proof-labeling. $O(\log(n+p))$-bit labels certifying a maximum $st$-flow value of $p$ in directed and undirected graphs with arbitrary capacities, optimal for $p\ge n^{Ω(1)}$, settling that regime of a question of Korman, Kutten, and Peleg (Distributed Computing 2010). - Merlin-Arthur verification. $\widetilde{O}(n^3)$ time and $O(n^3\log n)$ proof length for directed All-Pairs Max-Flow, improving on previous verification times of $n^{4+o(1)}$ for general capacities and $n^{3.5+o(1)}$ for unit capacities, and answering a question of Akmal (TheoretiCS 2024). - Nondeterministic algorithms. $O(n^{3.614})$ time for directed All-Pairs Max-Flow, or $n^{3.5+o(1)}$ if $ω=2$: the first subquartic bound for general edge capacities, answering a question of Trabelsi (SODA 2025).

Authors: Ohad Trabelsi

The textbook certificate for maximum flow is lopsided: the cut takes one bit per vertex, while the flow takes one number per edge. Indeed, some graphs have $Θ(n^2)$ terminal pairs for which every maximum flow uses $Θ(n^2)$ edges. Yet we show that one short number per vertex suffices for both cut and flow: $n$ vertex potentials, each rounded to $O(\log(nW))$ bits, certify the exact maximum $st$-flow value in any directed graph with integer capacities at most $W$. Exact potentials can have exponentially large representations. Rounding them may violate flow conservation, but the total error across any cut is less than one unit, so integrality of cut capacities absorbs it. Checking conservation is local and linear in the capacities, allowing the same certificate to yield new bounds in four models (capacities are polynomially bounded unless stated otherwise): - Online annotated streaming. $\widetilde{O}(n)$ total cost (help plus space) for the maximum $st$-flow value, optimal up to logarithmic factors, answering a question of Thaler (ICALP 2016) on whether $o(n^2)$ is possible. - Broadcast proof-labeling. $O(\log(n+p))$-bit labels certifying a maximum $st$-flow value of $p$ in directed and undirected graphs with arbitrary capacities, optimal for $p\ge n^{Ω(1)}$, settling that regime of a question of Korman, Kutten, and Peleg (Distributed Computing 2010). - Merlin-Arthur verification. $\widetilde{O}(n^3)$ time and $O(n^3\log n)$ proof length for directed All-Pairs Max-Flow, improving on previous verification times of $n^{4+o(1)}$ for general capacities and $n^{3.5+o(1)}$ for unit capacities, and answering a question of Akmal (TheoretiCS 2024). - Nondeterministic algorithms. $O(n^{3.614})$ time for directed All-Pairs Max-Flow, or $n^{3.5+o(1)}$ if $ω=2$: the first subquartic bound for general edge capacities, answering a question of Trabelsi (SODA 2025).

Online and Fully-Dynamic Sorting

from arXiv: Data Structures and Algorithms

Authors: Yossi Azar, Sujoy Bhore, Devdan Dey, Debmalya Panigrahi, Or Vardi, Ian Zhang

Online sorting asks how to place $n$ sequentially arriving elements in an array to minimize the sum of absolute differences between consecutive elements. Fully-dynamic sorting further extends the problem to allow both element insertions and deletions. Without recourse, these problems face strong lower bounds on the competitive ratio: $Ω(\sqrt{n})$ for online sorting and $Ω(n)$ for fully-dynamic sorting. In sharp contrast, we show that allowing only poly-logarithmic recourse yields at least exponential improvements in the competitive ratio for both problems:(1) Our main algorithmic result is a deterministic fully-dynamic sorting algorithm that is $O(\log^2 n)$-competitive and has $O(\log^4 n)$ amortized recourse per update. We complement this with a lower bound showing that any deterministic algorithm with any $O(\mathrm{polylog}(n))$ competitive ratio has amortized recourse at least $Ω(\sqrt{\log n})$.(2) For the insertion-only setting, we establish a family of approximation--recourse tradeoffs, including $O(\log\log n)$ competitive ratio with $O(\log\log n)$ amortized recourse. Given the lower bound in the fully-dynamic case, this result shows that the insertion-only problem yields exponentially better bounds than the fully-dynamic one.(3) Finally, we show that the stronger approximation-recourse tradeoff for the insertion-only case extends to the fully-dynamic setting when the array has $(1+\varepsilon)n$ space.

Authors: Yossi Azar, Sujoy Bhore, Devdan Dey, Debmalya Panigrahi, Or Vardi, Ian Zhang

Online sorting asks how to place $n$ sequentially arriving elements in an array to minimize the sum of absolute differences between consecutive elements. Fully-dynamic sorting further extends the problem to allow both element insertions and deletions. Without recourse, these problems face strong lower bounds on the competitive ratio: $Ω(\sqrt{n})$ for online sorting and $Ω(n)$ for fully-dynamic sorting. In sharp contrast, we show that allowing only poly-logarithmic recourse yields at least exponential improvements in the competitive ratio for both problems:(1) Our main algorithmic result is a deterministic fully-dynamic sorting algorithm that is $O(\log^2 n)$-competitive and has $O(\log^4 n)$ amortized recourse per update. We complement this with a lower bound showing that any deterministic algorithm with any $O(\mathrm{polylog}(n))$ competitive ratio has amortized recourse at least $Ω(\sqrt{\log n})$.(2) For the insertion-only setting, we establish a family of approximation--recourse tradeoffs, including $O(\log\log n)$ competitive ratio with $O(\log\log n)$ amortized recourse. Given the lower bound in the fully-dynamic case, this result shows that the insertion-only problem yields exponentially better bounds than the fully-dynamic one.(3) Finally, we show that the stronger approximation-recourse tradeoff for the insertion-only case extends to the fully-dynamic setting when the array has $(1+\varepsilon)n$ space.

Minimum Sum-of-Radii Clustering with Strong and Weak Oracles

from arXiv: Data Structures and Algorithms

Authors: Zachary Friggstad, Mahya Jamshidian, Ali Vakilian

In the minimum sum of radii (MSR) problem, the input is a set of $n$ points in a metric space and a parameter $k$, and the goal is to cover the points by at most $k$ balls, each centered at an input point, while minimizing the sum of their radii. We study MSR in the weak-strong oracle model of Bateni, Dharangutte, Jayaram, and Wang (COLT'24), where the metric is unknown and is accessed through two oracles. The answers of the weak oracle are given to us for free: for every pair of points, we receive a distance value that, with probability $δ$, is arbitrarily corrupted. Exact distances are available only through costly strong queries, where a strong query on a point reveals its exact distances to all previously strongly queried points, and the goal is to minimize the number of strong queries. For every constant $δ< 1/2$, we give the first polynomial-time algorithm that makes $O(k \log n \log\log n)$ strong point queries and, with high probability, returns an $O(1)$-approximation for MSR; the previously best algorithm required running time and a number of strong queries exponential in $k$. This is within an $O(\log\log n)$ factor of a lower bound that we prove: any constant-factor approximation that succeeds with high probability on every instance must make $Ω(k \log n)$ strong queries in expectation on some instance. The same $Ω(k \log n)$ lower bound holds for $k$-center, where it matches the known upper bound up to an $O(\log\log n)$ factor. An optimal MSR cluster can be small both in size and in radius, so a uniform sample of strongly queried points may miss it entirely. Instead, our algorithm uses a packing LP over the balls certified so far to decide which points to query next. The analysis holds against an adversary who knows which pairs are corrupted.

Authors: Zachary Friggstad, Mahya Jamshidian, Ali Vakilian

In the minimum sum of radii (MSR) problem, the input is a set of $n$ points in a metric space and a parameter $k$, and the goal is to cover the points by at most $k$ balls, each centered at an input point, while minimizing the sum of their radii. We study MSR in the weak-strong oracle model of Bateni, Dharangutte, Jayaram, and Wang (COLT'24), where the metric is unknown and is accessed through two oracles. The answers of the weak oracle are given to us for free: for every pair of points, we receive a distance value that, with probability $δ$, is arbitrarily corrupted. Exact distances are available only through costly strong queries, where a strong query on a point reveals its exact distances to all previously strongly queried points, and the goal is to minimize the number of strong queries. For every constant $δ< 1/2$, we give the first polynomial-time algorithm that makes $O(k \log n \log\log n)$ strong point queries and, with high probability, returns an $O(1)$-approximation for MSR; the previously best algorithm required running time and a number of strong queries exponential in $k$. This is within an $O(\log\log n)$ factor of a lower bound that we prove: any constant-factor approximation that succeeds with high probability on every instance must make $Ω(k \log n)$ strong queries in expectation on some instance. The same $Ω(k \log n)$ lower bound holds for $k$-center, where it matches the known upper bound up to an $O(\log\log n)$ factor. An optimal MSR cluster can be small both in size and in radius, so a uniform sample of strongly queried points may miss it entirely. Instead, our algorithm uses a packing LP over the balls certified so far to decide which points to query next. The analysis holds against an adversary who knows which pairs are corrupted.

Multi-seed information diffusion with varying reproduction

from arXiv: Data Structures and Algorithms

Authors: Erin Meger, Arianne Nantel, Nicholas Saloufakos, Jessica Enright

We define the $S_hR_k$-process that generalizes the notion of Hamiltonicity through the lense of information diffusion. We say that a graph is $S_hR_k$-infectable if it can be fully infected by transmission trees seeded by at most $h$ initial infections in which each infection leads to at most $k$ others; or, equivalently, if it can be exactly vertex-covered by at most $h$ trees of degree at most $k$. While determining $S_hR_k$ infectability is NP-hard in general, we argue fixed-parameter tractability when parameterised by treewidth. Additionally, we give computational experimental results comparing the performance of several natural heuristics for minimising the number of initial infections required to an optimal LP-based approach on several standard complex network models. We find that a uniformly random approach outperforms greedy heuristics based on degree or clustering.

Authors: Erin Meger, Arianne Nantel, Nicholas Saloufakos, Jessica Enright

We define the $S_hR_k$-process that generalizes the notion of Hamiltonicity through the lense of information diffusion. We say that a graph is $S_hR_k$-infectable if it can be fully infected by transmission trees seeded by at most $h$ initial infections in which each infection leads to at most $k$ others; or, equivalently, if it can be exactly vertex-covered by at most $h$ trees of degree at most $k$. While determining $S_hR_k$ infectability is NP-hard in general, we argue fixed-parameter tractability when parameterised by treewidth. Additionally, we give computational experimental results comparing the performance of several natural heuristics for minimising the number of initial infections required to an optimal LP-based approach on several standard complex network models. We find that a uniformly random approach outperforms greedy heuristics based on degree or clustering.

Tight Bounds for Non-Monotone Submodular Maximization under a Cardinality Constraint with Constant Recourse

from arXiv: Data Structures and Algorithms

Authors: Vaneet Aggarwal

We study the maximization of a nonnegative submodular function under a cardinality constraint when elements arrive one at a time and an algorithm must report a feasible set after every arrival. The recourse of an algorithm is the largest number of insertions and deletions that it makes to the reported set at a single arrival. For every $ε>0$, we give an algorithm with recourse $O(ε^{-2})$ whose reported set has, at every time, expected value at least $1/4-ε$ times the largest value of a feasible set of arrived elements. The algorithm evaluates the function polynomially often, and only on sets of arrived elements. We also show that no algorithm with constant recourse achieves a ratio above $1/4$, even if it knows the function and the arrival order in advance and has unlimited computation, and that any fixed ratio above $1/4$ requires recourse that grows as a positive power of the cardinality budget. Thus $1/4$ is the optimal limiting ratio with constant recourse. The previous best ratio with constant recourse was $3-2\sqrt2\approx0.172$. Our algorithm assigns selection probabilities of at most one half and maintains, as elements arrive, an inequality bounding the value of every feasible set by a multiple of the expected value of a random set drawn with these probabilities; the reported set moves to a rounding of these probabilities through gradual replacements. The upper bound uses a weighted directed graph whose vertices arrive in groups of decreasing sizes.

Authors: Vaneet Aggarwal

We study the maximization of a nonnegative submodular function under a cardinality constraint when elements arrive one at a time and an algorithm must report a feasible set after every arrival. The recourse of an algorithm is the largest number of insertions and deletions that it makes to the reported set at a single arrival. For every $ε>0$, we give an algorithm with recourse $O(ε^{-2})$ whose reported set has, at every time, expected value at least $1/4-ε$ times the largest value of a feasible set of arrived elements. The algorithm evaluates the function polynomially often, and only on sets of arrived elements. We also show that no algorithm with constant recourse achieves a ratio above $1/4$, even if it knows the function and the arrival order in advance and has unlimited computation, and that any fixed ratio above $1/4$ requires recourse that grows as a positive power of the cardinality budget. Thus $1/4$ is the optimal limiting ratio with constant recourse. The previous best ratio with constant recourse was $3-2\sqrt2\approx0.172$. Our algorithm assigns selection probabilities of at most one half and maintains, as elements arrive, an inequality bounding the value of every feasible set by a multiple of the expected value of a random set drawn with these probabilities; the reported set moves to a rounding of these probabilities through gradual replacements. The upper bound uses a weighted directed graph whose vertices arrive in groups of decreasing sizes.

Optimal Pattern-Avoidance Bounds for Binary Search Trees

from arXiv: Data Structures and Algorithms

Authors: Anita Dürr, Arturo Merino, Karol Węgrzycki, Sorrachai Yingchareonthawornchai

Self-adjusting binary search trees (BSTs) perform better than balanced BSTs if the access sequence has additional structure. For example, splay trees serve a sequential access sequence in linear time. Pattern avoidance captures regularity in an access sequence and unifies several classic examples of efficient BST access, such as deque and traversal sequences. A central question is how well a BST algorithm can exploit a pattern-avoiding access sequence. We present an online BST algorithm that serves an access sequence avoiding a permutation pattern $π$ in linear time, matching the information-theoretic lower bound. The algorithm does not need to know that pattern $π$ a priori. Our results answer an open problem asked by [Kozma 2016, Problem 44, strong variant]. Previously, the best known offline bound was optimal only for constant-size patterns [Berendsohn, Kozma, and Opler, STOC'24], and the best known online bound was superlinear [Chalermsook, Pettie, Yingchareonthawornchai, SODA'24] even for a constant-size pattern. As a corollary, our BST algorithm yields an optimal sorting algorithm for a pattern-avoiding sequence that supports online insertions. Previously, an optimal sorting algorithm was achieved using a mergesort-like approach [Opler, FOCS'24] in a batch setting. A key technique is to apply recursive split decomposition [Chalermsook, Chuzhoy, Saranurak, ToC'23] jointly in time and space, along with the Marcus-Tardos proof of the Stanley-Wilf conjecture. We show that the framework can be implemented online using $k$-finger BSTs, which is of independent interest. Finally, this framework also yields a constant-factor-approximation FPT algorithm in the offline setting.

Authors: Anita Dürr, Arturo Merino, Karol Węgrzycki, Sorrachai Yingchareonthawornchai

Self-adjusting binary search trees (BSTs) perform better than balanced BSTs if the access sequence has additional structure. For example, splay trees serve a sequential access sequence in linear time. Pattern avoidance captures regularity in an access sequence and unifies several classic examples of efficient BST access, such as deque and traversal sequences. A central question is how well a BST algorithm can exploit a pattern-avoiding access sequence. We present an online BST algorithm that serves an access sequence avoiding a permutation pattern $π$ in linear time, matching the information-theoretic lower bound. The algorithm does not need to know that pattern $π$ a priori. Our results answer an open problem asked by [Kozma 2016, Problem 44, strong variant]. Previously, the best known offline bound was optimal only for constant-size patterns [Berendsohn, Kozma, and Opler, STOC'24], and the best known online bound was superlinear [Chalermsook, Pettie, Yingchareonthawornchai, SODA'24] even for a constant-size pattern. As a corollary, our BST algorithm yields an optimal sorting algorithm for a pattern-avoiding sequence that supports online insertions. Previously, an optimal sorting algorithm was achieved using a mergesort-like approach [Opler, FOCS'24] in a batch setting. A key technique is to apply recursive split decomposition [Chalermsook, Chuzhoy, Saranurak, ToC'23] jointly in time and space, along with the Marcus-Tardos proof of the Stanley-Wilf conjecture. We show that the framework can be implemented online using $k$-finger BSTs, which is of independent interest. Finally, this framework also yields a constant-factor-approximation FPT algorithm in the offline setting.

IsaGraphLib: Formally Verified Efficient Graph Algorithms in Isabelle/HOL

from arXiv: Data Structures and Algorithms

Authors: Mohammad Abdulaziz, Thomas Ammer, Adem Rimpapa, Peter Lammich

We present a library of formally verified graph algorithms in Isabelle/HOL. The library covers the main problems of combinatorial optimisation on graphs: reachability, shortest paths, minimum spanning trees, matching, maximum flow, and minimum-cost flow. The algorithms in the library use most of the standard algorithm design techniques: graph search, greedy algorithms on matroids, dynamic programming, augmenting paths, blossom contraction, blocking flows, push-relabel, scaling, the primal-dual method, randomisation, and certificate checking. The library has adaptors between different types of graphs (directed, undirected, multigraphs), which allow results to be reused. Each algorithm is verified independently of its data structures, and the main algorithms are refined to efficient imperative implementations, from which we generate code in Standard ML, Scala, and Go. We developed parts of the library with large language models (LLMs), improved the quality of their proofs with a method based on statistics of our own proofs, and labelled which parts were developed by humans, by LLMs, or collaboratively. We perform a detailed experimental analysis of representative algorithms in our library, comparing it with state-of-the-art mainstream libraries, showing that our implementations are practical.

Authors: Mohammad Abdulaziz, Thomas Ammer, Adem Rimpapa, Peter Lammich

We present a library of formally verified graph algorithms in Isabelle/HOL. The library covers the main problems of combinatorial optimisation on graphs: reachability, shortest paths, minimum spanning trees, matching, maximum flow, and minimum-cost flow. The algorithms in the library use most of the standard algorithm design techniques: graph search, greedy algorithms on matroids, dynamic programming, augmenting paths, blossom contraction, blocking flows, push-relabel, scaling, the primal-dual method, randomisation, and certificate checking. The library has adaptors between different types of graphs (directed, undirected, multigraphs), which allow results to be reused. Each algorithm is verified independently of its data structures, and the main algorithms are refined to efficient imperative implementations, from which we generate code in Standard ML, Scala, and Go. We developed parts of the library with large language models (LLMs), improved the quality of their proofs with a method based on statistics of our own proofs, and labelled which parts were developed by humans, by LLMs, or collaboratively. We perform a detailed experimental analysis of representative algorithms in our library, comparing it with state-of-the-art mainstream libraries, showing that our implementations are practical.

Optimal mixing of random-to-random shuffling on linear extensions

from arXiv: Data Structures and Algorithms

Authors: Haoran Wang

Uniform sampling of linear extensions is a basic problem in randomized algorithms and the study of finite posets. We prove that the random-to-random shuffle of Ayyer, Schilling, and Thiéry mixes in $O(n\log n+n\log(1/\varepsilon))$ steps on every $n$-element poset, establishing their conjectured mixing order. With constant-time order queries, this gives an $\varepsilon$-approximate uniform sampler using $O(n^2(\log n+\log(1/\varepsilon)))$ elementary operations after preprocessing. The proof establishes relative-entropy contraction by a factor $1-1/n$ for the promotion half-step. Consequently, the uniform extended-promotion chain has the same mixing order. We represent complete promotion scans as reflected coordinate paths in the order polytope and prove that a convex potential with gradients in the same polytope has diagonal Hessian mass at most one along each path. Applying this estimate to an optimal transport potential yields a sharp entropy factorization for every finite-entropy input. Linearization also gives the spectral-gap lower bound $(n+1)/n^2$.

Authors: Haoran Wang

Uniform sampling of linear extensions is a basic problem in randomized algorithms and the study of finite posets. We prove that the random-to-random shuffle of Ayyer, Schilling, and Thiéry mixes in $O(n\log n+n\log(1/\varepsilon))$ steps on every $n$-element poset, establishing their conjectured mixing order. With constant-time order queries, this gives an $\varepsilon$-approximate uniform sampler using $O(n^2(\log n+\log(1/\varepsilon)))$ elementary operations after preprocessing. The proof establishes relative-entropy contraction by a factor $1-1/n$ for the promotion half-step. Consequently, the uniform extended-promotion chain has the same mixing order. We represent complete promotion scans as reflected coordinate paths in the order polytope and prove that a convex potential with gradients in the same polytope has diagonal Hessian mass at most one along each path. Applying this estimate to an optimal transport potential yields a sharp entropy factorization for every finite-entropy input. Linearization also gives the spectral-gap lower bound $(n+1)/n^2$.

Multiaccuracy as an Error Benchmark for Learning with Distribution Shift

from arXiv: Data Structures and Algorithms

Authors: Konstantinos Stavropoulos

Agnostic learning has a well-developed theory of computational and statistical complexity. For learning with distribution shift, even the choice of an appropriate error benchmark remains challenging. Testable learning with distribution shift (TDS) was introduced to develop computational foundations for this setting: using labeled training data and unlabeled test data, the learner must either produce a predictor with low test error or detect distribution shift. However, standard agnostic TDS guarantees allow a constant-factor amplification of the optimum error even when the training and test distributions coincide. They therefore do not directly recover the guarantee of classical agnostic learning. We introduce shift multiaccuracy, a stronger error benchmark inspired by multiaccuracy from algorithmic fairness. This yields a TDS formulation that becomes equivalent to multiaccuracy when there is no shift. Using a recent nontrivial reduction from agnostic learning to multiaccurate prediction from prior work, we obtain the first TDS framework that formally generalizes agnostic learning through an efficient reduction preserving the training marginal. The framework retains existing algorithmic upper bounds and inherits computational lower bounds from agnostic learning. Moreover, we establish a direct connection between our model and identity testing, yielding the first statistical characterization of agnostic TDS learning, in terms of Rademacher complexity. More broadly, we argue that shift multiaccuracy might be of independent interest in unsupervised domain adaptation, as it leads to sharper out-of-distribution generalization guarantees, and can be minimized directly, since its definition does not involve the unobserved test labels.

Authors: Konstantinos Stavropoulos

Agnostic learning has a well-developed theory of computational and statistical complexity. For learning with distribution shift, even the choice of an appropriate error benchmark remains challenging. Testable learning with distribution shift (TDS) was introduced to develop computational foundations for this setting: using labeled training data and unlabeled test data, the learner must either produce a predictor with low test error or detect distribution shift. However, standard agnostic TDS guarantees allow a constant-factor amplification of the optimum error even when the training and test distributions coincide. They therefore do not directly recover the guarantee of classical agnostic learning. We introduce shift multiaccuracy, a stronger error benchmark inspired by multiaccuracy from algorithmic fairness. This yields a TDS formulation that becomes equivalent to multiaccuracy when there is no shift. Using a recent nontrivial reduction from agnostic learning to multiaccurate prediction from prior work, we obtain the first TDS framework that formally generalizes agnostic learning through an efficient reduction preserving the training marginal. The framework retains existing algorithmic upper bounds and inherits computational lower bounds from agnostic learning. Moreover, we establish a direct connection between our model and identity testing, yielding the first statistical characterization of agnostic TDS learning, in terms of Rademacher complexity. More broadly, we argue that shift multiaccuracy might be of independent interest in unsupervised domain adaptation, as it leads to sharper out-of-distribution generalization guarantees, and can be minimized directly, since its definition does not involve the unobserved test labels.

Associahedra are 8-colourable

from arXiv: Data Structures and Algorithms

Authors: David R Wood

Determining the chromatic number of associahedra is a long-standing open problem. Tan [arXiv:2611.05323] recently proved that associahedra are 12-colourable, which is the first constant upper bound. This paper adapts Tan's argument to show that associahedra are 8-colourable.

Authors: David R Wood

Determining the chromatic number of associahedra is a long-standing open problem. Tan [arXiv:2611.05323] recently proved that associahedra are 12-colourable, which is the first constant upper bound. This paper adapts Tan's argument to show that associahedra are 8-colourable.

Tight Bounds for Differentially Private Cut Release

from arXiv: Data Structures and Algorithms

Authors: Chenghua Liu, Boning Meng

We give a polynomial-time algorithm for releasing a nonnegative weighted synthetic graph under $(\varepsilon,δ)$-edge differential privacy. Given an $n$-vertex nonnegative weighted graph $G=(V,w_G)$, the output $H=(V,w_H)$ satisfies, with probability at least $1-β$, simultaneously for every $S\subseteq V$, $|w_G(S,V\setminus S)-w_H(S,V\setminus S)| \leγw_G(S,V\setminus S)+O\bigl((n\log n)/(\varepsilonγ)\bigr)$, provided that $γ,\varepsilon,δ,β$ are at least inverse polynomial in $n$. For constant $γ,\varepsilon$ and $δ=β=n^{-10}$, this improves the recently obtained additive error bound of $O(n\log^7 n)$ to $O(n\log n)$. We also prove a matching $Ω(n\log n)$ lower bound. Our algorithm combines degree decomposition with private multiplicative weights, using a degree-sensitive semidefinite oracle to generate update proposals from single Gaussian samples. Each proposal is validated by a noisy check of its exact entropy decrease, and a joint Rényi analysis of sampling and validation avoids additional logarithmic losses.

Authors: Chenghua Liu, Boning Meng

We give a polynomial-time algorithm for releasing a nonnegative weighted synthetic graph under $(\varepsilon,δ)$-edge differential privacy. Given an $n$-vertex nonnegative weighted graph $G=(V,w_G)$, the output $H=(V,w_H)$ satisfies, with probability at least $1-β$, simultaneously for every $S\subseteq V$, $|w_G(S,V\setminus S)-w_H(S,V\setminus S)| \leγw_G(S,V\setminus S)+O\bigl((n\log n)/(\varepsilonγ)\bigr)$, provided that $γ,\varepsilon,δ,β$ are at least inverse polynomial in $n$. For constant $γ,\varepsilon$ and $δ=β=n^{-10}$, this improves the recently obtained additive error bound of $O(n\log^7 n)$ to $O(n\log n)$. We also prove a matching $Ω(n\log n)$ lower bound. Our algorithm combines degree decomposition with private multiplicative weights, using a degree-sensitive semidefinite oracle to generate update proposals from single Gaussian samples. Each proposal is validated by a noisy check of its exact entropy decrease, and a joint Rényi analysis of sampling and validation avoids additional logarithmic losses.

Cogirth-Strength Ratios and Matroid Rank Reduction

from arXiv: Data Structures and Algorithms

Authors: Yu Cong, Chao Xu, Yajie Zhao

In the rank-$p$ reduction problem, we are given a matroid with nonnegative element weights and seek a minimum-weight set of elements whose deletion lowers the rank by at least $p$. For graphic matroids, this is the minimum $(p+1)$-cut problem. Chekuri, Quanrud, and Xu developed a tree-packing algorithm for minimum $k$-cut, which relies on the fact that the minimum cut of a graph is at most twice its strength, the value of a maximum fractional packing of spanning trees. We generalize this approach from graphs to matroids. The matroid analogue of the minimum cut is the cogirth, the minimum weight of a cocircuit, and the analogue of graph strength is matroid strength, the value of a maximum fractional packing of bases. We show that if every matroid in a deletion-closed class has cogirth at most $d$ times its strength, then for every $p$, the natural linear programming relaxation of rank-$p$ reduction is within a factor of $d$ of the optimum. As a result, repeatedly deleting a minimum-weight cocircuit gives a $d$-approximation, and an optimal solution can be found deterministically in $n^{(2d-1)p+O(1)}$ time on $n$ elements. For graphs, $d=2$ and our framework specializes to the tree-packing approach. As applications, we bound the cogirth-strength ratio for two broad classes, and both bounds are tight. For quasi-graphic matroids, which include graphic, bicircular, frame, and lifted-graphic matroids, the ratio is at most $2$ for all weights, giving a $2$-approximation and an exact $n^{3p+O(1)}$-time algorithm. For $(k,\ell)$-count matroids of hypergraphs with $0\le \ell\le k$ and edge size at most $s$, the ratio is at most $ks$ under unit weights. This gives a $ks$-approximation and an exact $n^{(2ks-1)p+O(1)}$-time algorithm for unweighted rank-$p$ reduction.

Authors: Yu Cong, Chao Xu, Yajie Zhao

In the rank-$p$ reduction problem, we are given a matroid with nonnegative element weights and seek a minimum-weight set of elements whose deletion lowers the rank by at least $p$. For graphic matroids, this is the minimum $(p+1)$-cut problem. Chekuri, Quanrud, and Xu developed a tree-packing algorithm for minimum $k$-cut, which relies on the fact that the minimum cut of a graph is at most twice its strength, the value of a maximum fractional packing of spanning trees. We generalize this approach from graphs to matroids. The matroid analogue of the minimum cut is the cogirth, the minimum weight of a cocircuit, and the analogue of graph strength is matroid strength, the value of a maximum fractional packing of bases. We show that if every matroid in a deletion-closed class has cogirth at most $d$ times its strength, then for every $p$, the natural linear programming relaxation of rank-$p$ reduction is within a factor of $d$ of the optimum. As a result, repeatedly deleting a minimum-weight cocircuit gives a $d$-approximation, and an optimal solution can be found deterministically in $n^{(2d-1)p+O(1)}$ time on $n$ elements. For graphs, $d=2$ and our framework specializes to the tree-packing approach. As applications, we bound the cogirth-strength ratio for two broad classes, and both bounds are tight. For quasi-graphic matroids, which include graphic, bicircular, frame, and lifted-graphic matroids, the ratio is at most $2$ for all weights, giving a $2$-approximation and an exact $n^{3p+O(1)}$-time algorithm. For $(k,\ell)$-count matroids of hypergraphs with $0\le \ell\le k$ and edge size at most $s$, the ratio is at most $ks$ under unit weights. This gives a $ks$-approximation and an exact $n^{(2ks-1)p+O(1)}$-time algorithm for unweighted rank-$p$ reduction.

Important Cuts with Logical Constraints: A Meta-Theorem for Eulerian Digraphs

from arXiv: Data Structures and Algorithms

Authors: Václav Blažej, Satyabrata Jana, Jędrzej Olkowski, M. S. Ramanujan, Peter Strulo

Important separators are a standard tool in parameterized cut algorithms. An $S$-$T$ separator is important if it is inclusion-wise minimal and no separator of at most the same size leaves a strict superset of the vertices reachable from $S$ after deletion. Their use relies on a boundedness theorem: for fixed $k$, the number of important $S$-$T$ separators of size at most $k$ is at most a constant ($4^k$ to be precise) independent of the input size, even in directed graphs, and they can be enumerated efficiently. The classical theory, however, controls only the size of the separator, not the structure of the source side cut off by it. Once the source side is required to satisfy a condition such as acyclicity, bipartiteness, or another logical property, the corresponding maximal source sides can be unbounded in general digraphs. This obstruction is fundamentally related to hardness phenomena in directed deletion problems such as Directed Odd Cycle Transversal}. Prior to this work, even in undirected graphs, boundedness of such maximal constrained source sides was known only in more specialized settings, not at the level of generality considered in our work.

Authors: Václav Blažej, Satyabrata Jana, Jędrzej Olkowski, M. S. Ramanujan, Peter Strulo

Important separators are a standard tool in parameterized cut algorithms. An $S$-$T$ separator is important if it is inclusion-wise minimal and no separator of at most the same size leaves a strict superset of the vertices reachable from $S$ after deletion. Their use relies on a boundedness theorem: for fixed $k$, the number of important $S$-$T$ separators of size at most $k$ is at most a constant ($4^k$ to be precise) independent of the input size, even in directed graphs, and they can be enumerated efficiently. The classical theory, however, controls only the size of the separator, not the structure of the source side cut off by it. Once the source side is required to satisfy a condition such as acyclicity, bipartiteness, or another logical property, the corresponding maximal source sides can be unbounded in general digraphs. This obstruction is fundamentally related to hardness phenomena in directed deletion problems such as Directed Odd Cycle Transversal}. Prior to this work, even in undirected graphs, boundedness of such maximal constrained source sides was known only in more specialized settings, not at the level of generality considered in our work.

Matroid Parity Meets Vertex Splitting

from arXiv: Data Structures and Algorithms

Authors: Hitendra Kumar, Pritesh Kumar, Madhumita Kundu, Saket Saurabh

A vertex split replaces a vertex by two non-adjacent descendants and partitions its incident edges between them. We study exclusive $\ell$-shallow splitting, where each original vertex has at most $\ell+1$ descendants, with the aim of obtaining a forest, a pseudoforest, or a cluster graph. We consider two natural objectives: minimizing the total number of split operations and minimizing the number of original vertices that are split. Our main conceptual contribution is a connection between vertex splitting and matroid parity. For both forests and pseudoforests, we give a characterization of feasible splitting sequences that leads, via weighted linear matroid parity, to polynomial-time algorithms for minimizing the number of split vertices when $\ell=2$. These algorithms are complemented by NP-hardness for every fixed $\ell\ge3$; for pseudoforests, hardness holds even on graphs of maximum degree four. The total number of split operations behaves differently: for both sparse target classes, this objective is polynomial-time solvable for every $\ell$, using matroid intersection. For cluster graphs, both objectives admit linear-time algorithms when $\ell=1$ and are NP-hard for every fixed $\ell\ge2$. Together, these results identify how the target class, the local splitting bound, and the choice of objective determine the complexity of vertex splitting.

Authors: Hitendra Kumar, Pritesh Kumar, Madhumita Kundu, Saket Saurabh

A vertex split replaces a vertex by two non-adjacent descendants and partitions its incident edges between them. We study exclusive $\ell$-shallow splitting, where each original vertex has at most $\ell+1$ descendants, with the aim of obtaining a forest, a pseudoforest, or a cluster graph. We consider two natural objectives: minimizing the total number of split operations and minimizing the number of original vertices that are split. Our main conceptual contribution is a connection between vertex splitting and matroid parity. For both forests and pseudoforests, we give a characterization of feasible splitting sequences that leads, via weighted linear matroid parity, to polynomial-time algorithms for minimizing the number of split vertices when $\ell=2$. These algorithms are complemented by NP-hardness for every fixed $\ell\ge3$; for pseudoforests, hardness holds even on graphs of maximum degree four. The total number of split operations behaves differently: for both sparse target classes, this objective is polynomial-time solvable for every $\ell$, using matroid intersection. For cluster graphs, both objectives admit linear-time algorithms when $\ell=1$ and are NP-hard for every fixed $\ell\ge2$. Together, these results identify how the target class, the local splitting bound, and the choice of objective determine the complexity of vertex splitting.

A PTAS for Euclidean Capacitated Vehicle Routing

from arXiv: Data Structures and Algorithms

Authors: Zachary Friggstad, Fabrizio Grandoni, Ramin Mousavi, Kinter Ren, Mohammad R. Salavatipour

In the Capacitated Vehicle Routing Problem (CVRP), introduced by Dantzig and Ramser in 1959, we are given an $n$-node graph $G=(V,E)$ with metric edges costs $c(e)$, a depot $r\in V$, and an integer vehicle capacity $Q$. The goal is to find a minimum-cost collection of tours, each containing the depot and visiting at most other $Q$ nodes, such that the tours cover all the nodes. In this paper we focus on the Euclidean CVRP problem, where the nodes represent points on $\mathbb{R}^2$, and the edge costs are the respective Euclidean distances. Euclidean CVRP generalizes the classical NP-hard Euclidean TSP problem (the special case with $Q=n-1$), that admits a PTAS [Arora FOCS'96/Mitchell SODA'96]. A long-standing open problem has been generalizing the latter PTAS to Euclidean CVRP. A polynomial-time $(2+ε)$-approximation for this problem follows from the PTAS for Euclidean TSP and the tour-partitioning technique for CVRP [Haimovich, Kan Math. OR'85]. This was the best known until a recent improvement of the approximation factor to slightly below 2 [Friggstad, Grandoni, Mousavi SODA'26]. There have been a series of papers presenting improved QPTASs by Das and Mathieu [SODA'10] (time $n^{\log^{O(1/ε)}n}$), Jayaprakash and Salavatipour [SODA'22] (time $n^{O_ε(\log^6 n)}$), and recently Sitters [ArXiV'25] (time $n^{O_ε(\log\log n)}$). In this paper, we solve the mentioned long-standing open problem by presenting a PTAS for Euclidean CVRP.

Authors: Zachary Friggstad, Fabrizio Grandoni, Ramin Mousavi, Kinter Ren, Mohammad R. Salavatipour

In the Capacitated Vehicle Routing Problem (CVRP), introduced by Dantzig and Ramser in 1959, we are given an $n$-node graph $G=(V,E)$ with metric edges costs $c(e)$, a depot $r\in V$, and an integer vehicle capacity $Q$. The goal is to find a minimum-cost collection of tours, each containing the depot and visiting at most other $Q$ nodes, such that the tours cover all the nodes. In this paper we focus on the Euclidean CVRP problem, where the nodes represent points on $\mathbb{R}^2$, and the edge costs are the respective Euclidean distances. Euclidean CVRP generalizes the classical NP-hard Euclidean TSP problem (the special case with $Q=n-1$), that admits a PTAS [Arora FOCS'96/Mitchell SODA'96]. A long-standing open problem has been generalizing the latter PTAS to Euclidean CVRP. A polynomial-time $(2+ε)$-approximation for this problem follows from the PTAS for Euclidean TSP and the tour-partitioning technique for CVRP [Haimovich, Kan Math. OR'85]. This was the best known until a recent improvement of the approximation factor to slightly below 2 [Friggstad, Grandoni, Mousavi SODA'26]. There have been a series of papers presenting improved QPTASs by Das and Mathieu [SODA'10] (time $n^{\log^{O(1/ε)}n}$), Jayaprakash and Salavatipour [SODA'22] (time $n^{O_ε(\log^6 n)}$), and recently Sitters [ArXiV'25] (time $n^{O_ε(\log\log n)}$). In this paper, we solve the mentioned long-standing open problem by presenting a PTAS for Euclidean CVRP.

Monday, November 16

Overwhelming The Old System

from Ben Recht

How could a single faulty router cripple US aviation? Clearly, a conspiracy theory.

Hi there, argmin readers. Welcome to p(doom) week as we celebrate the Anthropic IPO. Today’s post is some gonzo journalism on Friday’s nationwide ground stop and how it relates to AI fearmongering.

Picking up my phone from the X-ray scanner at the sleepy TSA PreCheck line at the John Wayne Airport, I saw a text from a friend:

“i will blame Openai :p. i am sure that shit would happen eventually (i dont know if this is cyber related)”

He linked to an NBC News story declaring that the FAA had ordered a nationwide ground stop for all departing flights for safety reasons. There was no further explanation. I’d spend the next 6 hours trapped in a linear hallway of frustrated Disneyland tourists trying to figure out what was going on.

People almost immediately took to Twitter, claiming this was the dreaded AI gone rogue. It was too convenient that the FAA had rolled out a new SI tool just the day before.1 But from the get-go, the Trump administration downplayed fears of a cyberattack. By 2 PM Pacific Time, Homeland Security said it looked like a run-of-the-mill telecommunications outage. It just happened to be an outage on critical infrastructure. Whoopsies.

By 4 PM, CBS was reporting that some sort of update by the defense contractor L3Harris had crashed the system. I wrote to my group chat, “Does that mean they were trying to do an update in the middle of the day on a Friday? That can’t be right,” and immediately received the reply, “Your logic is sound, but we shouldn’t underestimate the stupidity of defense contractors.”

Still, it was really weird that there was no official update and we had to scour the internet for anonymous sources. There was no press conference, no briefing. Just chaos from coast to coast. I guess that sort of thing is to be expected, as we have a bunch of crony morons running our government. Even with my extremely low expectations of them, I was surprised the entire air transportation system shut down, and no one said anything. That only made the speculation worse.

The Departures board lit up with cancellations, but my flight back to Oakland stayed “delayed.” For about a half hour, it was listed as “departed,” even though I could see the plane parked at Gate 17. The airport slowly thinned out as people figured out alternative plans.

Bored out of my mind, I started up some conversations with the dwindling crowd. I talked to a guy who had been in the air during the September 11 attacks. He remembered flight attendants running up and down the aisles, and stories of planes flying into buildings all over the country. It would be too weird if we were in the same sort of sea of confusion over a preventable network error.

Eventually the stop was lifted, though it wasn’t at all clear I was getting home. I broke down and went to an authentic Orange County burger place with an airport outpost: Carl’s Jr. Have you heard of it? After 5 hours of sitting in impossibly uncomfortable gate chairs, the Western Bacon Cheeseburger was the most delicious burger I’ve ever eaten. And it was magical too. As soon as I had inhaled it, they called for us to get on the plane.

The flight had been full at 2 PM, but when we pushed off the gate around 7:30, only 29 people were on board. It was then a 30-second taxi, a completely uneventful 75-minute flight, and a short Uber ride, and I was home. I got off easy in the end.

Lots of travelers weren’t as lucky as I was, and I hope everyone has finally made it where they needed to be. This shouldn’t happen. There is absolutely no reason for our national transportation system to be completely crippled for a weekend without explanation. I watched the whole Saturday press conference with Transportation Secretary Duffman (from the Real World Boston) and his FAA subordinates. Duffy stuck to the story from the previous day:

L3Harris was doing “routine maintenance” at a “remote location” on the FAA IT network. They were in the process of modernizing the network, switching from copper to fiber. The contractor installed a router that started sending 200 pings a second. While this number is actually quite small in the grand scheme of things, this caused control-plane congestion in the other routers on the network, overloading their processors. Air traffic control observed this as “network instabilities,” like the ones I regularly get on my Zoom calls, but now at most major FAA communications centers across the country. Since they didn’t know at the time what was causing the instabilities, they grounded everyone out of “an abundance of caution.” No system ever went down, but they couldn’t triangulate the faulty hardware in Arkansas because their maintenance is logged on paper records (!!!). Once they took the faulty router offline, everything stabilized.

Duffy said we do these sorts of updates all the time, and no one had any idea a router in this location could cause this sort of problem. What brought the whole country’s transit to its knees was solved by “hello IT, have you tried turning it off and on again?”2

Now, we wanted to believe it was AI, because that would have been much more exciting than the truth. The truth is, our transportation system depends on an antiquated network. FAA head Bryan Bedford, who was previously famous for his stint on Undercover Boss, took a harder line: the FAA telecom system has been a known critical infrastructure weakness for two decades.

A private defense contractor owns, maintains, and runs this network. Exorbitant pricing and bureaucratic contracting run through opaque federal processes. It is impossible for citizens to hold these systems and actors accountable. The accountability instead depends on a federal workforce that has been reportedly slashed by the Trump administration and his moronic Musk-led efficiency goons. I’m not going to write out their idiotic, unfunny acronym.

It is odd that my left-leaning friends were so ready to blame AI run amok, as this conveys more techno-optimism than blaming the sad, crippled, crumbling infrastructure managed by a moron from The Real World Boston. But, as Kevin Baker notes, it’s easier to fear futuristic doomsday scenarios than to grapple with our real inability to stabilize the world in the present.

Subscribe now

1

If you think I’m being a chud for using the “SI” abbreviation, know that I think the term “AI” is just as stupid.

2

You can actually get a lot of good insights on what can go wrong in a network and potential explanations for this particular outage on subreddit r/it!

By Ben Recht

TR26-320 | Binary Two-Way Codes with Optimal Erasure Resilience | Zhijun Zhang, Klim Efremenko, Gillat Kol, Sergey Komech, Raghuvansh Saxena

from ECCC Papers

Two-way codes use communication in both directions to convey a message from a sender to a receiver over a noisy channel. In a beautiful work, [GKZ22] proved that for binary channels with adversarial erasures, interaction strictly outperforms one-way communication: they constructed a two-way code with erasure resilience approaching 3/5, surpassing the 1/2 upper bound for traditional binary codes implied by the Plotkin bound. They also proved that no binary two-way code can have erasure resilience greater than 2/3. Whether this bound could be approached remained a central open problem. We resolve this problem in the affirmative by constructing a deterministic binary two-way code that approaches the optimal erasure resilience of 2/3 while achieving constant rate and linear encoding and decoding times. Our construction is remarkably simple and takes an entirely different approach from prior work.
Two-way codes use communication in both directions to convey a message from a sender to a receiver over a noisy channel. In a beautiful work, [GKZ22] proved that for binary channels with adversarial erasures, interaction strictly outperforms one-way communication: they constructed a two-way code with erasure resilience approaching 3/5, surpassing the 1/2 upper bound for traditional binary codes implied by the Plotkin bound. They also proved that no binary two-way code can have erasure resilience greater than 2/3. Whether this bound could be approached remained a central open problem. We resolve this problem in the affirmative by constructing a deterministic binary two-way code that approaches the optimal erasure resilience of 2/3 while achieving constant rate and linear encoding and decoding times. Our construction is remarkably simple and takes an entirely different approach from prior work.

TR26-319 | Power and Limitations of TFNP Hierarchies | Surendra Ghentiyala, Oliver Korten, Toniann Pitassi

from ECCC Papers

It is well-known that if $\mathrm{P} = \mathrm{NP}$, then the seemingly larger class $\mathrm{PH}$ also collapses to $\mathrm{P}$; hence, we may base the hardness of $\mathrm{NP}$ on that of $\mathrm{PH}$, despite the widespread belief that $\mathrm{PH} \not\subseteq \mathrm{NP}$. Although well established in the decision problem setting, few such “conditional collapse theorems” are known for $\textit{total}$ $\mathrm{NP}$ search problems. In this work, by building on the ideas of Ghentiyala and Li [GL25] and drawing an analogy with the polynomial hierarchy, we study conditional collapses in $\mathrm{TFNP}$. Our primary focus is on the $\mathrm{WeakPigeon}$ hierarchy: the class of problems obtained by $\textit{iterating}$ the $\mathrm{WeakPigeon}$ problem via oracles (e.g. $\mathrm{WeakPigeon}, \mathrm{WeakPigeon}^{\mathrm{WeakPigeon}}, \mathrm{WeakPigeon}^{(\mathrm{WeakPigeon}^{\mathrm{WeakPigeon}})}$, etc.). First, we find that the problem of finding a multicollision of any fixed constant size (in a sufficiently compressing function) is contained in the $\mathrm{WeakPigeon}$ hierarchy, making it the first known $\mathrm{TFNP}$ problem where iteration non-trivially gives more power. Consequently, if $\mathrm{PWPP} = \mathrm{FP}$ then the problem of finding multicollisions also collapses to $\mathrm{FP}$. Our proof can be viewed as a reinterpretation of Buzek and Tessaro's "non-black-box" construction of collision resistant hash functions (CRHs) from multicollision-resistant hash functions (MCRHs) [BT24]. Interestingly, in the framework of $\mathrm{TFNP}$ problem iteration, this theorem follows from a black-box reduction, leading us to believe that $\mathrm{TFNP}$ problem iteration may be a useful explanatory framework for certain non-black-box constructions in cryptography. Our proposed shift in perspective also yields other new conditional collapses. For example, we see that if $\mathrm{PPP} = \mathrm{promiseUEOPL}$ or $\mathrm{PWPP} = \mathrm{LOSSY}$, then the problem of finding multicollisions also collapses to $\mathrm{promiseUEOPL}$ or $\mathrm{LOSSY}$ respectively. Having demonstrated that the $\mathrm{WeakPigeon}$ hierarchy is surprisingly powerful, we next show that it nonetheless does not contain the $\mathrm{TFNP}$ class $\mathrm{PPAD}$ (and hence any of its superclasses e.g. $\mathrm{PPP}, \mathrm{PPA}$) under black-box reductions. Our separation utilizes the connection between $\mathrm{TFNP}$ classes and proof complexity: we prove that bounded-depth Frege has efficient proofs of the tautology asserting the totality of problems in the $\mathrm{WeakPigeon}$ hierarchy, while on the other hand the tautology asserting the totality of $\mathrm{PPAD}$ is known to be hard for bounded-depth Frege. These insights into the structure of iterated $\mathrm{TFNP}$ problems inform us about both the promise and limitations of using our techniques to obtain further conditional collapses in $\mathrm{TFNP}$.
It is well-known that if $\mathrm{P} = \mathrm{NP}$, then the seemingly larger class $\mathrm{PH}$ also collapses to $\mathrm{P}$; hence, we may base the hardness of $\mathrm{NP}$ on that of $\mathrm{PH}$, despite the widespread belief that $\mathrm{PH} \not\subseteq \mathrm{NP}$. Although well established in the decision problem setting, few such “conditional collapse theorems” are known for $\textit{total}$ $\mathrm{NP}$ search problems. In this work, by building on the ideas of Ghentiyala and Li [GL25] and drawing an analogy with the polynomial hierarchy, we study conditional collapses in $\mathrm{TFNP}$. Our primary focus is on the $\mathrm{WeakPigeon}$ hierarchy: the class of problems obtained by $\textit{iterating}$ the $\mathrm{WeakPigeon}$ problem via oracles (e.g. $\mathrm{WeakPigeon}, \mathrm{WeakPigeon}^{\mathrm{WeakPigeon}}, \mathrm{WeakPigeon}^{(\mathrm{WeakPigeon}^{\mathrm{WeakPigeon}})}$, etc.). First, we find that the problem of finding a multicollision of any fixed constant size (in a sufficiently compressing function) is contained in the $\mathrm{WeakPigeon}$ hierarchy, making it the first known $\mathrm{TFNP}$ problem where iteration non-trivially gives more power. Consequently, if $\mathrm{PWPP} = \mathrm{FP}$ then the problem of finding multicollisions also collapses to $\mathrm{FP}$. Our proof can be viewed as a reinterpretation of Buzek and Tessaro's "non-black-box" construction of collision resistant hash functions (CRHs) from multicollision-resistant hash functions (MCRHs) [BT24]. Interestingly, in the framework of $\mathrm{TFNP}$ problem iteration, this theorem follows from a black-box reduction, leading us to believe that $\mathrm{TFNP}$ problem iteration may be a useful explanatory framework for certain non-black-box constructions in cryptography. Our proposed shift in perspective also yields other new conditional collapses. For example, we see that if $\mathrm{PPP} = \mathrm{promiseUEOPL}$ or $\mathrm{PWPP} = \mathrm{LOSSY}$, then the problem of finding multicollisions also collapses to $\mathrm{promiseUEOPL}$ or $\mathrm{LOSSY}$ respectively. Having demonstrated that the $\mathrm{WeakPigeon}$ hierarchy is surprisingly powerful, we next show that it nonetheless does not contain the $\mathrm{TFNP}$ class $\mathrm{PPAD}$ (and hence any of its superclasses e.g. $\mathrm{PPP}, \mathrm{PPA}$) under black-box reductions. Our separation utilizes the connection between $\mathrm{TFNP}$ classes and proof complexity: we prove that bounded-depth Frege has efficient proofs of the tautology asserting the totality of problems in the $\mathrm{WeakPigeon}$ hierarchy, while on the other hand the tautology asserting the totality of $\mathrm{PPAD}$ is known to be hard for bounded-depth Frege. These insights into the structure of iterated $\mathrm{TFNP}$ problems inform us about both the promise and limitations of using our techniques to obtain further conditional collapses in $\mathrm{TFNP}$.

Tight Quantum Query Bounds for Collision Finding over Arbitrary Bounded Types

from arXiv: Computational Complexity

Authors: Tianci Peng, Shiqi Hou, Xiaoyang Dong

We determine the bounded-error quantum query complexity of finding one $r$-collision in an $N$-input function of prescribed type, which specifies all equality-class sizes. For every fixed maximum class size and collision order, we give a tight bound as the maximum of scales determined by the numbers of classes of size at least $2,\ldots,r$. The lower bound holds for a uniformly random function of that type, and a matching algorithm succeeds on every such function. No intermediate class size is required to occur, and every feasible output alphabet is allowed. The characterization connects the abundant-collision regime associated with set equality to the sparse-target regime of $k$-distinctness. In particular, finding the unique $(k+1)$-collision in type $(k^n,k+1)$ has complexity $Θ_k(N^{3/4-1/[4(2^{k+1}-1)]})$, where $N=kn+k+1$, resolving an open problem of Belovs. For the lower bound, we introduce a filtered compressed permutation oracle that projects onto a harmonic database subspace after each complete function query. Its $O(T/N)$ comparison error over $T$ queries overcomes the square-root limitation of the unfiltered process. Hidden capacity extensions and moment estimates retain the populations at each intermediate collision order. Matching upper bounds use sampled collision lists and colored adaptive learning graphs, with a coherent decision-to-search conversion that avoids logarithmic overhead. We also give an alternative nested quantum-walk algorithm for three-collision search, matching the bound up to polylogarithmic factors.

Authors: Tianci Peng, Shiqi Hou, Xiaoyang Dong

We determine the bounded-error quantum query complexity of finding one $r$-collision in an $N$-input function of prescribed type, which specifies all equality-class sizes. For every fixed maximum class size and collision order, we give a tight bound as the maximum of scales determined by the numbers of classes of size at least $2,\ldots,r$. The lower bound holds for a uniformly random function of that type, and a matching algorithm succeeds on every such function. No intermediate class size is required to occur, and every feasible output alphabet is allowed. The characterization connects the abundant-collision regime associated with set equality to the sparse-target regime of $k$-distinctness. In particular, finding the unique $(k+1)$-collision in type $(k^n,k+1)$ has complexity $Θ_k(N^{3/4-1/[4(2^{k+1}-1)]})$, where $N=kn+k+1$, resolving an open problem of Belovs. For the lower bound, we introduce a filtered compressed permutation oracle that projects onto a harmonic database subspace after each complete function query. Its $O(T/N)$ comparison error over $T$ queries overcomes the square-root limitation of the unfiltered process. Hidden capacity extensions and moment estimates retain the populations at each intermediate collision order. Matching upper bounds use sampled collision lists and colored adaptive learning graphs, with a coherent decision-to-search conversion that avoids logarithmic overhead. We also give an alternative nested quantum-walk algorithm for three-collision search, matching the bound up to polylogarithmic factors.

Go under Chinese Rules with a Succinct Game History is Complete for Exponential Space

from arXiv: Computational Complexity

Authors: Markus Bläser, Felix Czerner

The complexity of games is a central topic in combinatorics, algorithms, and computational complexity theory. It asks how difficult it is to determine the winner of a combinatorial game under optimal play. Many games, such as Hex or Othello, are PSPACE-complete: the game tree has polynomial depth, so the game can be decided in PSPACE. However, some games allow exponentially long plays, for instance Chess (without a generalized 50-move rule) or Go under Japanese rules; these are complete for exponential time. To prevent infinite games, some games employ a no-repetition rule (super-ko rule), for instance Go under Chinese rules. Robson (1984) proved that Chess and Checkers with a no-repetition rule are even harder: deciding whether the first player has a winning strategy is EXPSPACE-complete. Since then, it has been an open problem whether Go with a no-repetition rule is EXPSPACE-complete, too. The complexity of a game under a no-repetition rule is typically interpreted as follows: given a board position, decide whether the first player has a winning strategy such that no repetition occurs from that position on. We introduce the concept of a succinct game history: a Boolean circuit that, given a board position, outputs 1 if the position is in the game history and 0 otherwise. It serves as a "judge" that tells the players whether a move is illegal because it creates a repetition. We prove that deciding whether Black has a winning strategy in Go with a no-repetition rule is EXPSPACE-complete when the game history is given succinctly. Moreover, the starting position in our hardness proof is reachable by legal gameplay, which has not always been the case in prior proofs.

Authors: Markus Bläser, Felix Czerner

The complexity of games is a central topic in combinatorics, algorithms, and computational complexity theory. It asks how difficult it is to determine the winner of a combinatorial game under optimal play. Many games, such as Hex or Othello, are PSPACE-complete: the game tree has polynomial depth, so the game can be decided in PSPACE. However, some games allow exponentially long plays, for instance Chess (without a generalized 50-move rule) or Go under Japanese rules; these are complete for exponential time. To prevent infinite games, some games employ a no-repetition rule (super-ko rule), for instance Go under Chinese rules. Robson (1984) proved that Chess and Checkers with a no-repetition rule are even harder: deciding whether the first player has a winning strategy is EXPSPACE-complete. Since then, it has been an open problem whether Go with a no-repetition rule is EXPSPACE-complete, too. The complexity of a game under a no-repetition rule is typically interpreted as follows: given a board position, decide whether the first player has a winning strategy such that no repetition occurs from that position on. We introduce the concept of a succinct game history: a Boolean circuit that, given a board position, outputs 1 if the position is in the game history and 0 otherwise. It serves as a "judge" that tells the players whether a move is illegal because it creates a repetition. We prove that deciding whether Black has a winning strategy in Go with a no-repetition rule is EXPSPACE-complete when the game history is given succinctly. Moreover, the starting position in our hardness proof is reachable by legal gameplay, which has not always been the case in prior proofs.

On Applications of Polynomial-Time Group Isomorphism Algorithm

from arXiv: Computational Complexity

Authors: Wenkang Zhang, Zhinan Wang, Jincheng Zhuang

The group isomorphism problem is a fundamental problem in computational group theory and is closely related to many other problems. Recently, Qiao and Zhang proposed a polynomial-time algorithm for finite group isomorphism in the multiplication-table model that computes the coset of all isomorphisms. Based on the algorithm of Qiao and Zhang, we study applications to finite associative ring isomorphism, bilinear map isotopism over finite commutative rings and free three-tensor isomorphism over finite commutative rings. First, we obtain a polynomial-time algorithm that returns the coset of all isomorphisms for finite associative rings. Second, we extend efficient isotopism and isomorphism algorithms for bilinear maps and free three-tensors from fields to general finite commutative rings.

Authors: Wenkang Zhang, Zhinan Wang, Jincheng Zhuang

The group isomorphism problem is a fundamental problem in computational group theory and is closely related to many other problems. Recently, Qiao and Zhang proposed a polynomial-time algorithm for finite group isomorphism in the multiplication-table model that computes the coset of all isomorphisms. Based on the algorithm of Qiao and Zhang, we study applications to finite associative ring isomorphism, bilinear map isotopism over finite commutative rings and free three-tensor isomorphism over finite commutative rings. First, we obtain a polynomial-time algorithm that returns the coset of all isomorphisms for finite associative rings. Second, we extend efficient isotopism and isomorphism algorithms for bilinear maps and free three-tensors from fields to general finite commutative rings.

Tight Quantum Query Bounds for Minimum Cut and Multicut on Dense Graphs

from arXiv: Data Structures and Algorithms

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We determine the dense worst-case quantum query complexity of exact minimum multicut on simple unweighted undirected graphs. With at most $k$ explicit demand pairs, our adjacency-array algorithm uses $\OO(n+\min\{m,n^{3/2}\sqrt{k}\})$ queries; a matching lower bound holds for every $1\le k\le\lfloor n/2\rfloor$ and sufficiently large $n$, with constants uniform in $k$. In particular, the $k=1$ case gives an $\OO(n^{3/2})$ query algorithm for prescribed $s$--$t$ cut. The upper bound combines degree-sensitive spectral estimates of local improvement with refinement by unions of label classes. These steps retain every original optimum and permit exact acquisition without an additional label-count factor. Separately, we prove an $Ω(n^{3/2})$ global minimum-cut lower bound on dense connected graphs, matching the existing upper bound up to polylogarithmic factors. It holds for the value and for any optimum shore, even with known degrees and sorted neighbor arrays; regular hard instances have balanced optimum cuts. Both lower bounds use degree-preserving switches and classify optimum outputs across a hidden threshold. Our upper bound concerns input queries, not total running time: computation on acquired data may be exponential, even in the single-demand case. Matching bounds at each prescribed sparse edge count are not established.

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We determine the dense worst-case quantum query complexity of exact minimum multicut on simple unweighted undirected graphs. With at most $k$ explicit demand pairs, our adjacency-array algorithm uses $\OO(n+\min\{m,n^{3/2}\sqrt{k}\})$ queries; a matching lower bound holds for every $1\le k\le\lfloor n/2\rfloor$ and sufficiently large $n$, with constants uniform in $k$. In particular, the $k=1$ case gives an $\OO(n^{3/2})$ query algorithm for prescribed $s$--$t$ cut. The upper bound combines degree-sensitive spectral estimates of local improvement with refinement by unions of label classes. These steps retain every original optimum and permit exact acquisition without an additional label-count factor. Separately, we prove an $Ω(n^{3/2})$ global minimum-cut lower bound on dense connected graphs, matching the existing upper bound up to polylogarithmic factors. It holds for the value and for any optimum shore, even with known degrees and sorted neighbor arrays; regular hard instances have balanced optimum cuts. Both lower bounds use degree-preserving switches and classify optimum outputs across a hidden threshold. Our upper bound concerns input queries, not total running time: computation on acquired data may be exponential, even in the single-demand case. Matching bounds at each prescribed sparse edge count are not established.

Exact Failure Probabilities for d-Choice Cuckoo Hashing

from arXiv: Data Structures and Algorithms

Authors: Chenyang Zhang, Ling Ren

In d-choice cuckoo hashing, each of n items must be placed in one of its d candidate slots in a table of M slots, and every slot holds at most one item. We give a polynomial-time dynamic programming algorithm to compute the exact probability that no valid placement exists. Our method also handles the variant with separate tables.

Authors: Chenyang Zhang, Ling Ren

In d-choice cuckoo hashing, each of n items must be placed in one of its d candidate slots in a table of M slots, and every slot holds at most one item. We give a polynomial-time dynamic programming algorithm to compute the exact probability that no valid placement exists. Our method also handles the variant with separate tables.

LinearKnot: Linear-Time Approximation of the Pseudoknot Partition Function

from arXiv: Data Structures and Algorithms

Authors: Milan Gautam, David H. Mathews, Liang Huang

Pseudoknots, where two or more helices cross, are central to many functional RNAs, including frameshifting signals, telomerase RNA, riboswitches and viral genomes. With arbitrary pseudoknots, finding the minimum free energy structure is NP-hard, so most RNA secondary structure prediction tools only consider pseudoknot-free structures. Dirks and Pierce (DP03) pioneered the first pseudoknot partition function, which underlies NUPACK's pseudoknot model, but it takes $O(n^5)$ time and $O(n^4)$ memory, making it practical only for very short sequences. Linear-time approximate dynamic programming, as in LinearFold and LinearPartition, does not transfer easily to DP03: a partial pseudoknot leaves a gap filled by its crossing partner, whose complementary sequence may still lie ahead of the scan, so it cannot be ranked by its inside weight. We present LinearKnot, a linear-time approximation of DP03 in three passes: (a) LinearPartition gives pseudoknot-free weights; (b) a second pass builds tables that estimate each partial stem's crossing partner; and (c) a third scans a left-to-right reformulation of DP03 that reserves the 5' nucleotides in the pseudoknot helix for subsequent pairing, keeping the states with the largest estimated contribution. Without pruning, this reformulation computes DP03's pseudoknot recursion exactly, so the only approximation is which states the beam keeps. End-to-end, time grows linearly ($n^{1.01}$) and memory marginally above linear ($n^{1.15}$) from 1,000 to 9,392 nt. LinearKnot folds the 9,392 nt Rous sarcoma virus genome in 2.4 hours and 90.5 GB, where exact DP03 would need an estimated 40,000 years and 54 million GB, and matches exact DP03 base-pair probabilities on 418 PseudoBase RNAs with a median RMSD of $9.2\times10^{-7}$. Our code is available at github.com/gautammilan/LinearKnot.

Authors: Milan Gautam, David H. Mathews, Liang Huang

Pseudoknots, where two or more helices cross, are central to many functional RNAs, including frameshifting signals, telomerase RNA, riboswitches and viral genomes. With arbitrary pseudoknots, finding the minimum free energy structure is NP-hard, so most RNA secondary structure prediction tools only consider pseudoknot-free structures. Dirks and Pierce (DP03) pioneered the first pseudoknot partition function, which underlies NUPACK's pseudoknot model, but it takes $O(n^5)$ time and $O(n^4)$ memory, making it practical only for very short sequences. Linear-time approximate dynamic programming, as in LinearFold and LinearPartition, does not transfer easily to DP03: a partial pseudoknot leaves a gap filled by its crossing partner, whose complementary sequence may still lie ahead of the scan, so it cannot be ranked by its inside weight. We present LinearKnot, a linear-time approximation of DP03 in three passes: (a) LinearPartition gives pseudoknot-free weights; (b) a second pass builds tables that estimate each partial stem's crossing partner; and (c) a third scans a left-to-right reformulation of DP03 that reserves the 5' nucleotides in the pseudoknot helix for subsequent pairing, keeping the states with the largest estimated contribution. Without pruning, this reformulation computes DP03's pseudoknot recursion exactly, so the only approximation is which states the beam keeps. End-to-end, time grows linearly ($n^{1.01}$) and memory marginally above linear ($n^{1.15}$) from 1,000 to 9,392 nt. LinearKnot folds the 9,392 nt Rous sarcoma virus genome in 2.4 hours and 90.5 GB, where exact DP03 would need an estimated 40,000 years and 54 million GB, and matches exact DP03 base-pair probabilities on 418 PseudoBase RNAs with a median RMSD of $9.2\times10^{-7}$. Our code is available at https://github.com/gautammilan/LinearKnot.

Fault Tolerant Coresets

from arXiv: Data Structures and Algorithms

Authors: Milind Prabhu, Chris Schwiegelshohn, Sudarshan Shyam

Coresets are small weighted summaries of large datasets that help quickly evaluate some loss objectives on the input dataset. We mainly focus on coresets for the $k$-means objective, where the cost of the input dataset with respect to a set of $k$ centers is the sum of squared distances from each point to its closest center. A $k$-means $\varepsilon$-coreset $Ω$ satisfies $\mathrm{cost}(P,S)=(1\pm\varepsilon)\mathrm{cost}(Ω,S)$ for every set $S$ of $k$ centers, where $P$ denotes the input dataset. A long line of work has established near optimal $\varepsilon$-coreset size bounds for $k$-means. A key assumption in these works is that the coreset remains intact after construction. The question we ask is the following: if an adversary corrupts at most $f$ weighted entries of an $\varepsilon$-coreset, can we recover an $O(\varepsilon)$-coreset via a decoding algorithm that is given only the corrupted coreset. This models situations where entries of the coreset can be corrupted during storage or transmission, and recovery must proceed without access to the original dataset. Our main result shows that increasing the usual coreset size by an additive $O(fk/\varepsilon)$ yields a coreset that can be decoded into an $O(\varepsilon)$-coreset after any $f$ adversarial corruptions. This bound is achieved by sensitivity sampling, a widely used method for constructing coresets. Our result is optimal in the sense that any fault tolerant coreset, whose decoding algorithm only keeps a subset of the points must also have size $Ω(fk/\varepsilon)$. Our experiments demonstrate recovery under adversarial corruptions.

Authors: Milind Prabhu, Chris Schwiegelshohn, Sudarshan Shyam

Coresets are small weighted summaries of large datasets that help quickly evaluate some loss objectives on the input dataset. We mainly focus on coresets for the $k$-means objective, where the cost of the input dataset with respect to a set of $k$ centers is the sum of squared distances from each point to its closest center. A $k$-means $\varepsilon$-coreset $Ω$ satisfies $\mathrm{cost}(P,S)=(1\pm\varepsilon)\mathrm{cost}(Ω,S)$ for every set $S$ of $k$ centers, where $P$ denotes the input dataset. A long line of work has established near optimal $\varepsilon$-coreset size bounds for $k$-means. A key assumption in these works is that the coreset remains intact after construction. The question we ask is the following: if an adversary corrupts at most $f$ weighted entries of an $\varepsilon$-coreset, can we recover an $O(\varepsilon)$-coreset via a decoding algorithm that is given only the corrupted coreset. This models situations where entries of the coreset can be corrupted during storage or transmission, and recovery must proceed without access to the original dataset. Our main result shows that increasing the usual coreset size by an additive $O(fk/\varepsilon)$ yields a coreset that can be decoded into an $O(\varepsilon)$-coreset after any $f$ adversarial corruptions. This bound is achieved by sensitivity sampling, a widely used method for constructing coresets. Our result is optimal in the sense that any fault tolerant coreset, whose decoding algorithm only keeps a subset of the points must also have size $Ω(fk/\varepsilon)$. Our experiments demonstrate recovery under adversarial corruptions.

Quantum Algorithm with Quadratic Speedup for 2D Pattern Matching

from arXiv: Data Structures and Algorithms

Authors: Rishabh Gala, Rahul Shah

We consider the problem of 2 dimensional pattern matching under Quantum Query model. Here, we are given a rectangular text $T[0..n_1-1][0..n_2-1]$ and a pattern $P[0..m_1 -1][0..m_2-1]$. We take $N = n_1n_2$ and $M = m_1m_2$ as the sizes of text and the pattern respectively (we assume $M < N$). Based upon the Quantum Advantage given by Grover's search (and subsequent Dürr-Høyer search), we create a solution which takes $\tilde{O}(\sqrt{N})$ query complexity to answer if the pattern $P$ exists in $T$. Our solution uses deterministic sampling as a primary component. As noted by earlier work in the literature, deterministic sampling is inadequate and witness tables are essential components for 2D matching. In our settings, we assume that the witness table of the pattern is precomputed classically and is available as an oracle to the quantum algorithm. Our main novel component is how to compute and employ a geometric structure called ``skyline" without losing the quantum advantage.

Authors: Rishabh Gala, Rahul Shah

We consider the problem of 2 dimensional pattern matching under Quantum Query model. Here, we are given a rectangular text $T[0..n_1-1][0..n_2-1]$ and a pattern $P[0..m_1 -1][0..m_2-1]$. We take $N = n_1n_2$ and $M = m_1m_2$ as the sizes of text and the pattern respectively (we assume $M < N$). Based upon the Quantum Advantage given by Grover's search (and subsequent Dürr-Høyer search), we create a solution which takes $\tilde{O}(\sqrt{N})$ query complexity to answer if the pattern $P$ exists in $T$. Our solution uses deterministic sampling as a primary component. As noted by earlier work in the literature, deterministic sampling is inadequate and witness tables are essential components for 2D matching. In our settings, we assume that the witness table of the pattern is precomputed classically and is available as an oracle to the quantum algorithm. Our main novel component is how to compute and employ a geometric structure called ``skyline" without losing the quantum advantage.

Dual-Slack Frontier Matching: Parallel Approximate Maximum-Product Matching

from arXiv: Data Structures and Algorithms

Authors: Marc A. Tunnell, Oguz Selvitopi, Xiaoye Sherry Li

Maximum-product bipartite matching supports scaling and static pivot selection in sparse matrix preprocessing. We present Dual-Slack Frontier Matching (DSFM), a deterministic, shared-memory parallel algorithm for approximate maximum-product matching. Motivated by heavy matchings on small candidate supports, DSFM searches progressively exposed subgraphs ordered by fixed dual slack. Slack-ordered certified completion guarantees a perfect matching whenever one exists, or a maximum-cardinality matching with a Hall certificate otherwise. Every returned perfect matching carries an a posteriori geometric-mean quality bound; accumulated Hall obstructions can tighten this bound and improve the returned scaling. We compare DSFM with Heavy-Weight Perfect Matching (HWPM) and exact MC64 assignment on 598 nonsingular matrices. DSFM attains higher matching quality than HWPM over most quality thresholds. On a set of large instances consisting of 37 matrices, DSFM achieves a $3.53\times$ geometric-mean speedup over MC64, compared to $2.29\times$ for HWPM.

Authors: Marc A. Tunnell, Oguz Selvitopi, Xiaoye Sherry Li

Maximum-product bipartite matching supports scaling and static pivot selection in sparse matrix preprocessing. We present Dual-Slack Frontier Matching (DSFM), a deterministic, shared-memory parallel algorithm for approximate maximum-product matching. Motivated by heavy matchings on small candidate supports, DSFM searches progressively exposed subgraphs ordered by fixed dual slack. Slack-ordered certified completion guarantees a perfect matching whenever one exists, or a maximum-cardinality matching with a Hall certificate otherwise. Every returned perfect matching carries an a posteriori geometric-mean quality bound; accumulated Hall obstructions can tighten this bound and improve the returned scaling. We compare DSFM with Heavy-Weight Perfect Matching (HWPM) and exact MC64 assignment on 598 nonsingular matrices. DSFM attains higher matching quality than HWPM over most quality thresholds. On a set of large instances consisting of 37 matrices, DSFM achieves a $3.53\times$ geometric-mean speedup over MC64, compared to $2.29\times$ for HWPM.

Adversarially Batched Online Learning

from arXiv: Data Structures and Algorithms

Authors: Mingda Qiao, Kerui Wu

We introduce adversarially batched online learning, where the learner may update its decision rule only at a restricted set of time steps. Equivalently, the time horizon is partitioned into batches, within which the learner must use a fixed policy. We study this model for four canonical problems: stochastic bandits, online convex optimization, prediction with expert advice, and adversarial bandits. For stochastic bandits, we identify a universal complexity measure based on relative batch growth and establish both gap-dependent and gap-independent regret bounds. We show that the multiplicative penalty relative to the standard gap-dependent complexity can grow superlinearly in batch hardness. For the remaining three, we show that the optimal regret is tightly characterized by the 2-norm of the batch-length sequence. The upper bound is achieved by a batch-oblivious learner who does not know the batch structure, via a generic adaptive doubling trick tailored to this complexity measure. In contrast, the lower bound holds even for batch-aware learners.

Authors: Mingda Qiao, Kerui Wu

We introduce adversarially batched online learning, where the learner may update its decision rule only at a restricted set of time steps. Equivalently, the time horizon is partitioned into batches, within which the learner must use a fixed policy. We study this model for four canonical problems: stochastic bandits, online convex optimization, prediction with expert advice, and adversarial bandits. For stochastic bandits, we identify a universal complexity measure based on relative batch growth and establish both gap-dependent and gap-independent regret bounds. We show that the multiplicative penalty relative to the standard gap-dependent complexity can grow superlinearly in batch hardness. For the remaining three, we show that the optimal regret is tightly characterized by the 2-norm of the batch-length sequence. The upper bound is achieved by a batch-oblivious learner who does not know the batch structure, via a generic adaptive doubling trick tailored to this complexity measure. In contrast, the lower bound holds even for batch-aware learners.

Collective Tree Exploration with Predictions

from arXiv: Data Structures and Algorithms

Authors: Romain Cosson, Yichen Huang, Michael Mitzenmacher, Ali Vakilian

We study collective tree exploration with subtree-size predictions. In this problem, a team of $k$ mobile agents needs to explore an unknown rooted tree as fast as possible, and whenever a new vertex $u$ is discovered, the team receives a prediction $\hat n_u$ of the number of nodes $n_u$ in the subtree rooted at $u$. We provide algorithmic guarantees under two error measures: the maximum error $E=\max_u|\widehat n_u-n_u|$ and the multiplicative distortion $μ= (\max_u\widehat n_u/n_u)(\max_u n_u/\widehat n_u)$. For the maximum error, we present a deterministic algorithm that explores any tree with $n$ nodes and depth $D$ in $O(\text{OPT}+E)$ rounds, where $\text{OPT} = Θ(n/k+D)$ is the offline benchmark, and we show that there is no deterministic algorithm that admits an $O(\text{OPT})+o(E)$ guarantee. For the multiplicative distortion, we present several algorithms that induce a competitive ratio in $\widetilde O(\min\{ \sqrtμ\log k, μ\log\log k+μ^{1.5} \})$, where the $\widetilde O(\cdot)$ may hide logarithmic factors in $μ$.

Authors: Romain Cosson, Yichen Huang, Michael Mitzenmacher, Ali Vakilian

We study collective tree exploration with subtree-size predictions. In this problem, a team of $k$ mobile agents needs to explore an unknown rooted tree as fast as possible, and whenever a new vertex $u$ is discovered, the team receives a prediction $\hat n_u$ of the number of nodes $n_u$ in the subtree rooted at $u$. We provide algorithmic guarantees under two error measures: the maximum error $E=\max_u|\widehat n_u-n_u|$ and the multiplicative distortion $μ= (\max_u\widehat n_u/n_u)(\max_u n_u/\widehat n_u)$. For the maximum error, we present a deterministic algorithm that explores any tree with $n$ nodes and depth $D$ in $O(\text{OPT}+E)$ rounds, where $\text{OPT} = Θ(n/k+D)$ is the offline benchmark, and we show that there is no deterministic algorithm that admits an $O(\text{OPT})+o(E)$ guarantee. For the multiplicative distortion, we present several algorithms that induce a competitive ratio in $\widetilde O(\min\{ \sqrtμ\log k, μ\log\log k+μ^{1.5} \})$, where the $\widetilde O(\cdot)$ may hide logarithmic factors in $μ$.

From smoothed analysis to backward error: The power of adaptive perturbations

from arXiv: Data Structures and Algorithms

Authors: Michał Dereziński, Michael W. Mahoney, Raphael A. Meyer, Christopher Musco

Smoothed analysis has become a central tool in theoretical computer science, often allowing for significant improvements to worst-case running times if we settle for a solution to a small random perturbation of the problem instance. This is closely related to the classical concept of backward error in numerical analysis, which allows an algorithm to return a solution to an arbitrary perturbation of the problem. Despite the qualitative similarity of these concepts, we show that they can exhibit large quantitative differences. Notably, we prove that, while a linear system with any $n \times n$ matrix $A$ can be solved to backward error $ε$ using $O(\log(n) / ε)$ matrix-vector products with $A$, any algorithm that solves a random $ε$-sized perturbation of $A$ requires $Ω(n)$ matrix-vector products. This means that a useful perturbation for solving a linear system in backward error must be adaptive to the input. Interestingly, however, randomness is still essential: we show that any deterministic method that attains small backward error for all linear systems provably requires $Ω(n)$ matrix-vector products, resulting in the first separation between randomized and deterministic algorithms in a natural computational model for solving linear systems. Finally, we show that matrix structure can significantly affect backward error complexity. For example, we show a deterministic $O(1/ε)$ matrix-vector product algorithm for symmetric linear systems.

Authors: Michał Dereziński, Michael W. Mahoney, Raphael A. Meyer, Christopher Musco

Smoothed analysis has become a central tool in theoretical computer science, often allowing for significant improvements to worst-case running times if we settle for a solution to a small random perturbation of the problem instance. This is closely related to the classical concept of backward error in numerical analysis, which allows an algorithm to return a solution to an arbitrary perturbation of the problem. Despite the qualitative similarity of these concepts, we show that they can exhibit large quantitative differences. Notably, we prove that, while a linear system with any $n \times n$ matrix $A$ can be solved to backward error $ε$ using $O(\log(n) / ε)$ matrix-vector products with $A$, any algorithm that solves a random $ε$-sized perturbation of $A$ requires $Ω(n)$ matrix-vector products. This means that a useful perturbation for solving a linear system in backward error must be adaptive to the input. Interestingly, however, randomness is still essential: we show that any deterministic method that attains small backward error for all linear systems provably requires $Ω(n)$ matrix-vector products, resulting in the first separation between randomized and deterministic algorithms in a natural computational model for solving linear systems. Finally, we show that matrix structure can significantly affect backward error complexity. For example, we show a deterministic $O(1/ε)$ matrix-vector product algorithm for symmetric linear systems.

Tight Bounds for k-Median++ and Improved Bounds for k-Means++

from arXiv: Data Structures and Algorithms

Authors: Haim Kaplan, David Naori

The popular $k$-means++ algorithm, or $D^\ell$-sampling, is a fundamental primitive in both the theory and practice of clustering. In the bi-criteria setting, the algorithm samples $k+Δ$ centers ($Δ\ge0$), and its cost is compared with the optimum using $k$ centers. Despite extensive study over the past two decades, its exact approximation ratio and tight bi-criteria guarantees remain unknown. We give a unified analysis for every distance exponent $\ell>0$, every $k\ge1$, and every $Δ\ge0$. For metric $k$-median, our bounds are tight for all $k$ and $Δ$. Without extra centers, the exact approximation ratio is $2(1+H_{k-1})$ (also in Euclidean space), improving the previous upper bound by a factor of $2$ ($H_j$ denotes the $j$th harmonic number). This tight analysis reveals that even one extra center improves the approximation ratio by an additive $Θ(\log\log k)$, whereas previous bounds show no improvement. For every $\ell>0$, our analysis gives upper bounds with the same dependence on $k$ and $Δ$ as our tight bound for metric $k$-median, with leading constants depending only on $\ell$ and whether the metric is Euclidean. Beyond the improved dependence on $Δ$, our leading constants are smaller than those in previous analyses. In particular, for the widely used Euclidean $k$-means objective, our upper bound without extra centers is $(1+\varphi)(1+H_{k-1})$, where $\varphi\approx1.618$ is the golden ratio, improving upon the previous constant of $5$. With oversampling, a constant fraction of extra centers is known to provide a constant-factor approximation. For example, with $10\%$ extra centers, our guarantee is $5.7$, compared with the best previous guarantee of $25.9$.

Authors: Haim Kaplan, David Naori

The popular $k$-means++ algorithm, or $D^\ell$-sampling, is a fundamental primitive in both the theory and practice of clustering. In the bi-criteria setting, the algorithm samples $k+Δ$ centers ($Δ\ge0$), and its cost is compared with the optimum using $k$ centers. Despite extensive study over the past two decades, its exact approximation ratio and tight bi-criteria guarantees remain unknown. We give a unified analysis for every distance exponent $\ell>0$, every $k\ge1$, and every $Δ\ge0$. For metric $k$-median, our bounds are tight for all $k$ and $Δ$. Without extra centers, the exact approximation ratio is $2(1+H_{k-1})$ (also in Euclidean space), improving the previous upper bound by a factor of $2$ ($H_j$ denotes the $j$th harmonic number). This tight analysis reveals that even one extra center improves the approximation ratio by an additive $Θ(\log\log k)$, whereas previous bounds show no improvement. For every $\ell>0$, our analysis gives upper bounds with the same dependence on $k$ and $Δ$ as our tight bound for metric $k$-median, with leading constants depending only on $\ell$ and whether the metric is Euclidean. Beyond the improved dependence on $Δ$, our leading constants are smaller than those in previous analyses. In particular, for the widely used Euclidean $k$-means objective, our upper bound without extra centers is $(1+\varphi)(1+H_{k-1})$, where $\varphi\approx1.618$ is the golden ratio, improving upon the previous constant of $5$. With oversampling, a constant fraction of extra centers is known to provide a constant-factor approximation. For example, with $10\%$ extra centers, our guarantee is $5.7$, compared with the best previous guarantee of $25.9$.

A Common Improved Bound for Asymmetric TSP and Path TSP

from arXiv: Data Structures and Algorithms

Authors: MohammadTaghi Hajiaghayi, Changki Yun

We give polynomial-time $(R_*+\varepsilon)$-approximation algorithms for asymmetric TSP and asymmetric path TSP, for every fixed $\varepsilon>0$, where $R_*=6+\sqrt2+\sqrt{15+6\sqrt2}\approx12.2604$. Both guarantees hold relative to the corresponding subtour relaxations, whose integrality ratios are therefore at most $R_*$. This improves the previous guarantees of below $14.7$ for asymmetric TSP and $15$ for asymmetric path TSP [Vygen, 2026]. Our algorithms strengthen subtour covers and recursive augmentation in the laminar framework [Svensson, Tarnawski, Vegh, JACM'20; Traub, Vygen, 2025]. The recursive analysis retains the paths through contracted regions and accounts jointly for their cost and the dual mass they visit. We also improve the reduction from asymmetric path TSP to vertebrate pairs [Traub, Vygen, 2025] by comparing two initial walks with complementary completion bounds. Applied to Vygen's existing vertebrate-pair algorithm, this reduction alone improves the path factor from $15$ to below $14.7$, matching his asymmetric TSP guarantee.

Authors: MohammadTaghi Hajiaghayi, Changki Yun

We give polynomial-time $(R_*+\varepsilon)$-approximation algorithms for asymmetric TSP and asymmetric path TSP, for every fixed $\varepsilon>0$, where $R_*=6+\sqrt2+\sqrt{15+6\sqrt2}\approx12.2604$. Both guarantees hold relative to the corresponding subtour relaxations, whose integrality ratios are therefore at most $R_*$. This improves the previous guarantees of below $14.7$ for asymmetric TSP and $15$ for asymmetric path TSP [Vygen, 2026]. Our algorithms strengthen subtour covers and recursive augmentation in the laminar framework [Svensson, Tarnawski, Vegh, JACM'20; Traub, Vygen, 2025]. The recursive analysis retains the paths through contracted regions and accounts jointly for their cost and the dual mass they visit. We also improve the reduction from asymmetric path TSP to vertebrate pairs [Traub, Vygen, 2025] by comparing two initial walks with complementary completion bounds. Applied to Vygen's existing vertebrate-pair algorithm, this reduction alone improves the path factor from $15$ to below $14.7$, matching his asymmetric TSP guarantee.

A Framework for Cost-Preserving Rounding with Applications to Laminar Thin Trees

from arXiv: Data Structures and Algorithms

Authors: Jannis Blauth, Rico Zenklusen

In the context of finding thin trees, like laminarly-thin trees or globally-thin trees, it turned out to be challenging to round a fractional solution to an integral one without losing cost, while only having a constant-factor violation of the thinness constraints. We provide a general framework for this problem, in a much broader context, that reduces the problem to finding a certain type of rounding algorithm with only an approximate prize guarantee. We show that, up to a change in constants, the rounding problem with approximate prize guarantee that we use is equivalent to the original question. As an application, we obtain a polynomial-time algorithm that finds a laminar constantly-thin tree of cost no higher than the one of the natural linear programming solution, thus obtaining the first result without cost loss of this type (even for the special case of chain-constrained trees). Moreover, our framework gives a new perspective on how to approach the problem of finding globally-thin trees without cost loss.

Authors: Jannis Blauth, Rico Zenklusen

In the context of finding thin trees, like laminarly-thin trees or globally-thin trees, it turned out to be challenging to round a fractional solution to an integral one without losing cost, while only having a constant-factor violation of the thinness constraints. We provide a general framework for this problem, in a much broader context, that reduces the problem to finding a certain type of rounding algorithm with only an approximate prize guarantee. We show that, up to a change in constants, the rounding problem with approximate prize guarantee that we use is equivalent to the original question. As an application, we obtain a polynomial-time algorithm that finds a laminar constantly-thin tree of cost no higher than the one of the natural linear programming solution, thus obtaining the first result without cost loss of this type (even for the special case of chain-constrained trees). Moreover, our framework gives a new perspective on how to approach the problem of finding globally-thin trees without cost loss.

Color Refinement Distinguishes Connected Rooted Outerplanar Graphs

from arXiv: Data Structures and Algorithms

Authors: Louann Coste, M{ó}nika Csik{ó}s, Laurent Viennot

Color refinement, also known as the $1$-dimensional Weisfeiler-Leman algorithm ($1$-WL), is a classical near-linear-time heuristic for graph isomorphism, which also captures the expressive power of message-passing graph neural networks. A long line of work asks on which graph classes $1$-WL, or its higher-dimensional variant $k$-WL, identifies every graph; the least such $k$ is the WL-dimension of the class. Planar graphs have WL-dimension at most $3$ (Kiefer, Ponomarenko and Schweitzer, 2019), and whether $2$-WL already distinguishes all planar graphs is a central open problem. We bring new insight on this question for outerplanar graphs, whose WL-dimension is $2$. We show that color refinement, i.e. 1-WL, distinguishes connected rooted outerplanar graphs: two non-isomorphic such graphs receive different stable colorings once a single vertex, the root, is individualized. The root is necessary, as there are non-isomorphic $2$-connected outerplanar graphs that color refinement does not distinguish. Our result extends to pseudo-rooted graphs, in which the stable coloring merely contains a singleton color class, and to non-connected graphs whose components all contain such a class. Consequently, the $(1,1)$-WL test of Rattan and Seppelt (2023) distinguishes all outerplanar graphs. We proceed by inversion: we reconstruct a connected rooted outerplanar graph, up to isomorphism, from its color graph, the weighted quotient of the graph by its stable color classes, together with its root color. The reconstruction runs in time linear in the output size and is canonical, which yields a near-linear-time canonization algorithm for these graphs. Our main tool is a dichotomy lemma, formalized in Rocq: in a rooted outerplanar graph with an equitable coloring, every block either receives pairwise distinct colors or admits a color-preserving mirror symmetry fixing its vertex closest to the root.

Authors: Louann Coste, M{ó}nika Csik{ó}s, Laurent Viennot

Color refinement, also known as the $1$-dimensional Weisfeiler-Leman algorithm ($1$-WL), is a classical near-linear-time heuristic for graph isomorphism, which also captures the expressive power of message-passing graph neural networks. A long line of work asks on which graph classes $1$-WL, or its higher-dimensional variant $k$-WL, identifies every graph; the least such $k$ is the WL-dimension of the class. Planar graphs have WL-dimension at most $3$ (Kiefer, Ponomarenko and Schweitzer, 2019), and whether $2$-WL already distinguishes all planar graphs is a central open problem. We bring new insight on this question for outerplanar graphs, whose WL-dimension is $2$. We show that color refinement, i.e. 1-WL, distinguishes connected rooted outerplanar graphs: two non-isomorphic such graphs receive different stable colorings once a single vertex, the root, is individualized. The root is necessary, as there are non-isomorphic $2$-connected outerplanar graphs that color refinement does not distinguish. Our result extends to pseudo-rooted graphs, in which the stable coloring merely contains a singleton color class, and to non-connected graphs whose components all contain such a class. Consequently, the $(1,1)$-WL test of Rattan and Seppelt (2023) distinguishes all outerplanar graphs. We proceed by inversion: we reconstruct a connected rooted outerplanar graph, up to isomorphism, from its color graph, the weighted quotient of the graph by its stable color classes, together with its root color. The reconstruction runs in time linear in the output size and is canonical, which yields a near-linear-time canonization algorithm for these graphs. Our main tool is a dichotomy lemma, formalized in Rocq: in a rooted outerplanar graph with an equitable coloring, every block either receives pairwise distinct colors or admits a color-preserving mirror symmetry fixing its vertex closest to the root.

How rigid is maximum cardinality search? Stability and locality of MCS orderings under edge updates, verified in Lean

from arXiv: Data Structures and Algorithms

Authors: Md Thoriqul Islam Thonmay, Gregory Morse

For which sets F of edge modifications do a graph G and the modified graph share a maximum cardinality search (MCS) ordering? We prove that they do whenever, along every proper common MCS prefix, each unchosen vertex's neighbour count in the second graph exceeds its count in the first by zero or one. In particular, inserting or deleting any matching, or flipping a single edge, preserves a common ordering, and under the same hypothesis every common MCS prefix extends to a full common ordering without backtracking. Neither part of the hypothesis can simply be dropped: inserting a triangle, a P_4 or a 2P_3 shows that the +1 bound cannot be relaxed to +2, and a disjoint mixed insert/delete pair shows that the one-directional condition is needed. For the canonical ordering (smallest-index tie-breaking) under a single-edge update, an insertion can first change the ordering only strictly between the endpoints' positions, and a deletion only at the later endpoint; when no break fires, the ordering is unchanged. A boolean-adjacency executable refines the abstract probe-then-repair update. All of these results, including the four obstructions, are proved in Lean 4 over Mathlib, re-checked by independent kernel checkers, and registered in the Palomar registry. On paper we further show that the first break of an insertion is located in O((deg(v)+1) log n) time, independent of the window length. We claim no worst-case asymptotic speedup over recomputation.

Authors: Md Thoriqul Islam Thonmay, Gregory Morse

For which sets F of edge modifications do a graph G and the modified graph share a maximum cardinality search (MCS) ordering? We prove that they do whenever, along every proper common MCS prefix, each unchosen vertex's neighbour count in the second graph exceeds its count in the first by zero or one. In particular, inserting or deleting any matching, or flipping a single edge, preserves a common ordering, and under the same hypothesis every common MCS prefix extends to a full common ordering without backtracking. Neither part of the hypothesis can simply be dropped: inserting a triangle, a P_4 or a 2P_3 shows that the +1 bound cannot be relaxed to +2, and a disjoint mixed insert/delete pair shows that the one-directional condition is needed. For the canonical ordering (smallest-index tie-breaking) under a single-edge update, an insertion can first change the ordering only strictly between the endpoints' positions, and a deletion only at the later endpoint; when no break fires, the ordering is unchanged. A boolean-adjacency executable refines the abstract probe-then-repair update. All of these results, including the four obstructions, are proved in Lean 4 over Mathlib, re-checked by independent kernel checkers, and registered in the Palomar registry. On paper we further show that the first break of an insertion is located in O((deg(v)+1) log n) time, independent of the window length. We claim no worst-case asymptotic speedup over recomputation.

Exact-Quota Facility Location: A Transfer Framework and Three Approximation Guarantees

from arXiv: Data Structures and Algorithms

Authors: Hang Luo

Facility location with outliers asks which facilities to open and which clients to serve, subject to a prescribed service quota. We give a framework for transferring facility-location cost certificates to this exact-quota setting. The framework yields deterministic polynomial-time approximation guarantees of $571/376<1.52$ for metric facility location with outliers, strictly less than $1.853$ for priority facility location with outliers, and $2.16995<2.17$ for squared-metric facility location with outliers. Each algorithm serves the prescribed number of clients and pays the original facility-opening costs. The framework separates initialization from improvement. A growth process is stopped when it first reaches the quota; deleting excess clients from its last batch leaves a payment deficit supported on a bounded number of facilities. Greedy additions then reoptimize the served client set. A threshold-coverage representation makes the resulting service cost supermodular and allows the usual density analysis to compare different client sets. Finally, enumerating and prepaying a constant number of expensive facilities absorbs the exceptional costs. A transfer theorem states exactly which initialization certificate is sufficient and how many prepaid facilities it requires. The three applications supply this certificate in different ways. The metric case uses a quota prefix of reassigning JMS; the priority case uses persistent contributions and a cleanup ordered by service level; and the squared-metric case uses a local factor-revealing certificate valid for arbitrary client subsets of the same run. We provide complete finite proofs of the numerical interfaces, including an exact rational certificate for the squared-metric bound.

Authors: Hang Luo

Facility location with outliers asks which facilities to open and which clients to serve, subject to a prescribed service quota. We give a framework for transferring facility-location cost certificates to this exact-quota setting. The framework yields deterministic polynomial-time approximation guarantees of $571/376<1.52$ for metric facility location with outliers, strictly less than $1.853$ for priority facility location with outliers, and $2.16995<2.17$ for squared-metric facility location with outliers. Each algorithm serves the prescribed number of clients and pays the original facility-opening costs. The framework separates initialization from improvement. A growth process is stopped when it first reaches the quota; deleting excess clients from its last batch leaves a payment deficit supported on a bounded number of facilities. Greedy additions then reoptimize the served client set. A threshold-coverage representation makes the resulting service cost supermodular and allows the usual density analysis to compare different client sets. Finally, enumerating and prepaying a constant number of expensive facilities absorbs the exceptional costs. A transfer theorem states exactly which initialization certificate is sufficient and how many prepaid facilities it requires. The three applications supply this certificate in different ways. The metric case uses a quota prefix of reassigning JMS; the priority case uses persistent contributions and a cleanup ordered by service level; and the squared-metric case uses a local factor-revealing certificate valid for arbitrary client subsets of the same run. We provide complete finite proofs of the numerical interfaces, including an exact rational certificate for the squared-metric bound.

The Complexity of Traffic Engineering in Segment Routing Networks

from arXiv: Data Structures and Algorithms

Authors: Matthias Bentert, Stefan Schmid

Segment routing is a modern variant of source routing which has recently become popular in the Internet. It allows operators to equip network packets with an additional header which specifies segments: a list of waypoints the packet needs to traverse on its way to the destination. This is reminiscent of Valiant routing in parallel computing and introduces an additional degree of freedom in traffic engineering. This flexibility can be exploited to minimize congestion in the network. This paper sheds light on the computational complexity of traffic engineering in segment routing networks. We consider two problem variants: a fixed-length variant where link weights are given and only waypoints can be chosen, and a variable-length variant where additionally the network operator can also choose the link weights, which then define the shortest paths taken between the waypoints. We prove that the first variant is NP-hard even if the network graph is planar and if all demands and link weights are 1. We also show that the second variant is NP-hard already for planar network graphs with all demands being 1. On the positive side, we present a compact and general mixed integer linear program to compute exact solutions for the first variant.

Authors: Matthias Bentert, Stefan Schmid

Segment routing is a modern variant of source routing which has recently become popular in the Internet. It allows operators to equip network packets with an additional header which specifies segments: a list of waypoints the packet needs to traverse on its way to the destination. This is reminiscent of Valiant routing in parallel computing and introduces an additional degree of freedom in traffic engineering. This flexibility can be exploited to minimize congestion in the network. This paper sheds light on the computational complexity of traffic engineering in segment routing networks. We consider two problem variants: a fixed-length variant where link weights are given and only waypoints can be chosen, and a variable-length variant where additionally the network operator can also choose the link weights, which then define the shortest paths taken between the waypoints. We prove that the first variant is NP-hard even if the network graph is planar and if all demands and link weights are 1. We also show that the second variant is NP-hard already for planar network graphs with all demands being 1. On the positive side, we present a compact and general mixed integer linear program to compute exact solutions for the first variant.

Long rational and Gaussian integer multiplication

from arXiv: Data Structures and Algorithms

Authors: Yuval Spiizer, Raphael S. Steiner

Long integer multiplication is a fundamental operation in computational algebra, heavily relying on Toom--Cook and related evaluation-interpolation algorithms. Conventional wisdom dictates that multiplication on the Gaussian integers $\mathbb{Z}[i]$ is reduced to standard rational integer multiplication, since $\mathbb{Z}[i]$ is a ring extension of $\mathbb{Z}$. We show that this approach is far from optimal and moreover inverting this established paradigm, that is reducing rational to Gaussian multiplication, leads to faster rational integer multiplication algorithms. We introduce a novel Toom--Cook framework that reduces rational long integer multiplication to Gaussian integer multiplication, yielding a strictly more efficient computational pipeline. By taking advantage of the special properties of the rational integer domain inside the Gaussian integers, we achieve a more favourable algebraic structure that reduces the overall arithmetic cost in every metric. To validate this theoretical shift, we provide a complete implementation of our algorithm. Benchmarks demonstrate that our approach outperforms the highly optimised GNU Multiple Precision Arithmetic Library (GMP) by up to 29\%, bridging a fundamental theoretical insight with significant practical improvements in high-performance computer algebra.

Authors: Yuval Spiizer, Raphael S. Steiner

Long integer multiplication is a fundamental operation in computational algebra, heavily relying on Toom--Cook and related evaluation-interpolation algorithms. Conventional wisdom dictates that multiplication on the Gaussian integers $\mathbb{Z}[i]$ is reduced to standard rational integer multiplication, since $\mathbb{Z}[i]$ is a ring extension of $\mathbb{Z}$. We show that this approach is far from optimal and moreover inverting this established paradigm, that is reducing rational to Gaussian multiplication, leads to faster rational integer multiplication algorithms. We introduce a novel Toom--Cook framework that reduces rational long integer multiplication to Gaussian integer multiplication, yielding a strictly more efficient computational pipeline. By taking advantage of the special properties of the rational integer domain inside the Gaussian integers, we achieve a more favourable algebraic structure that reduces the overall arithmetic cost in every metric. To validate this theoretical shift, we provide a complete implementation of our algorithm. Benchmarks demonstrate that our approach outperforms the highly optimised GNU Multiple Precision Arithmetic Library (GMP) by up to 29\%, bridging a fundamental theoretical insight with significant practical improvements in high-performance computer algebra.

Parameterized Approximation for Minimizing Uncovered Elements and Unsatisfied Constraints

from arXiv: Data Structures and Algorithms

Authors: Rudranarayan Kar, Souvik Saha, Abhishek Sahu

Min-UnCoverage asks for at most $k$ sets minimizing uncovered weight. Min-Unsat SAT and Min-Unsat CSP ask for an assignment with at most $k$ true variables minimizing the weight of unsatisfied clauses or constraints. For constraints of arity at most $d$, we give a deterministic $(1+\varepsilon)$-approximation for weighted Min-Unsat CSP in $(dk/\varepsilon)^{O(k)}N^{O(1)}$ time, where $N$ is the input size. This also gives approximation schemes for bounded-arity SAT and coverage with bounded element frequency. We show that weighted coverage with set size at most $d$ can be solved exactly in $2^{O(kd)}N^{O(1)}$ time by adapting color-coding. For coverage on incidence graphs of bounded semi-ladder index, we give a deterministic parameterized approximation scheme . We show that, unless $\mathrm{FPT}=\mathrm{W}[1]$, SAT and CSP have no finite-factor FPT approximation parameterized by $k+d$ when variable frequency is at most $d$, or on $K_{3,3}$-free incidence graphs of semi-ladder index at most four. Known Hitting Set hardness gives the same lower bound for all three problems at VC dimension two. Under the same assumption, we show that no computable relaxation $g(k,d)\geq k$ allows an FPT algorithm to preserve a prescribed unsatisfied-weight target for SAT or CSP, already for arity three and, separately, bounded variable frequency. For coverage, known algorithms preserve the target using at most $k+1$ sets on incidence graphs of bounded semi-ladder index.

Authors: Rudranarayan Kar, Souvik Saha, Abhishek Sahu

Min-UnCoverage asks for at most $k$ sets minimizing uncovered weight. Min-Unsat SAT and Min-Unsat CSP ask for an assignment with at most $k$ true variables minimizing the weight of unsatisfied clauses or constraints. For constraints of arity at most $d$, we give a deterministic $(1+\varepsilon)$-approximation for weighted Min-Unsat CSP in $(dk/\varepsilon)^{O(k)}N^{O(1)}$ time, where $N$ is the input size. This also gives approximation schemes for bounded-arity SAT and coverage with bounded element frequency. We show that weighted coverage with set size at most $d$ can be solved exactly in $2^{O(kd)}N^{O(1)}$ time by adapting color-coding. For coverage on incidence graphs of bounded semi-ladder index, we give a deterministic parameterized approximation scheme . We show that, unless $\mathrm{FPT}=\mathrm{W}[1]$, SAT and CSP have no finite-factor FPT approximation parameterized by $k+d$ when variable frequency is at most $d$, or on $K_{3,3}$-free incidence graphs of semi-ladder index at most four. Known Hitting Set hardness gives the same lower bound for all three problems at VC dimension two. Under the same assumption, we show that no computable relaxation $g(k,d)\geq k$ allows an FPT algorithm to preserve a prescribed unsatisfied-weight target for SAT or CSP, already for arity three and, separately, bounded variable frequency. For coverage, known algorithms preserve the target using at most $k+1$ sets on incidence graphs of bounded semi-ladder index.

Sunday, November 15

Postdoc Positions in Quantum Computing and AI at Université de Sherbrooke (Quebec, Canada) (apply by December 1 3, 2026)

from CCI: jobs

The research group of Cunlu Zhou at Université de Sherbrooke seeks postdocs in quantum algorithms, quantum error correction, quantum learning, AI for quantum computing, and related areas. The positions involve collaborations with IBM Quantum, Mila, and other partners. Salary: CAD $70–80k/year. Apply by December 13, 2026, for full consideration; rolling review thereafter. Website: academicjobsonline.org/ajo/jobs/33368 Email: […]

The research group of Cunlu Zhou at Université de Sherbrooke seeks postdocs in quantum algorithms, quantum error correction, quantum learning, AI for quantum computing, and related areas. The positions involve collaborations with IBM Quantum, Mila, and other partners. Salary: CAD $70–80k/year. Apply by December 13, 2026, for full consideration; rolling review thereafter.

Website: https://academicjobsonline.org/ajo/jobs/33368
Email: complexe.quantique@USherbrooke.ca

By shacharlovett

Linkage

from David Eppstein

How Wikipedia’s editors (try to) keep the online encyclopedia human-written (\(\mathbb{M}\), via). Eliza Strickland of IEEE Spectrum interviews Ellia Lebleu, a founding member of Wikipedia’s AI Cleanup project.
  • How Wikipedia’s editors (try to) keep the online encyclopedia human-written (\(\mathbb{M}\), via). Eliza Strickland of IEEE Spectrum interviews Ellia Lebleu, a founding member of Wikipedia’s AI Cleanup project.

  • Analyzing the simplex method by-the-book (\(\mathbb{M}\)). 21-minute STOC’26 video by Sophie Huiberts and her collaborators, explaining why the rounding and random perturbations commonly used in implementations of the simplex method for linear programming make it behave differently from worst-case exponential examples, converging in polynomial time to good solutions for well-scaled input instances. See also their STOC paper.

  • I’m pretty sure I’ve complained about this before (\(\mathbb{M}\)), but when my campus’s photographer (officially a managing producer-director in the Office of Strategic Communications & Public Affairs) comes around to take free faculty/staff portraits, as he does every couple of years, he tells us “you can do what you want with them”, but it’s not true. It’s a work for hire, so the copyright on the photos is owned by the Regents of the University of California, who will not release them under an open-access Creative Commons license, so they cannot be used for instance on Wikipedia. Nobody has figured out the cheat codes for this piece of bureaucracy, so we end up getting a nice set of photos that are not actually as usable as they should be.

    Anyway, I have a new headshot. I kind of like how it came out, but the best my family will say about it is “it looks like you”. To spare you all from having to look at my no-longer-middle-aged face, I won’t inline it here, but you can find a copy on my home page.

  • A dot planimeter (\(\mathbb{M}\)) is just a fancy name for a transparent sheet with a square grid of dots printed onto it. You can estimate the areas of shapes by overlaying it on the shape and counting the dots. Now another Good Article on Wikipedia.

  • University libraries are being swarmed by AI bots, putting public access at risk (\(\mathbb{M}\)), says the CBC.

  • Richard Schwartz discovers how to fold the simplest origami torus (\(\mathbb{M}\)). Manon Bischoff in Scientific American; see also Schwartz’s PNAS paper.

  • I upgraded my phone today (\(\mathbb{M}\)), at an office of my service provider, a couple miles from my house. As I was finishing up the purchase, the sales clerk asked me a question so unexpected that I had to stop for a few seconds to figure out what she meant: Do you know how to get home?

    The point was that my phone wouldn’t be able to map the way for me until I had set it up. I almost never use in-car maps; if it’s not a place I’ve been before, I’d much prefer to study a map beforehand and memorize the route, and if (as in this case) I’ve been there before I can remember it. But so many people today have lost that skill and in many cases can’t even read a map. I find it all a bit sad.

    So yes, I did know how to get home.

  • I made this illustration (\(\mathbb{M}\)) for the Wikipedia article on the problem of folding a square to make a shape of greater perimeter than you started with. It depicts a map from a square to a tree, that does not increase any distance (a “short map”), but that does increase the perimeter of its image. Each red circle or blue circular arc in the square is mapped to its thick centerline at the point where it crosses the centerline; these centerlines become the branches of the tree. The yellow regions of the square are all mapped to a single point where the branches meet. The perimeter of the black part of the tree is the same as the square; the doubled length of the red branch is added on top of that. Svetlana Krat’s 2005 Ph.D. thesis includes both this map (and its generalization to rectangles) and a method of approximating short maps by foldings, to give a novel solution to the napkin folding problem.

    Krat's short map from a square to a tree of greater perimeter

  • Why are rivers so mathematical? (\(\mathbb{M}\)). Natalie Wolchover in Quanta on the scaling laws of river networks.

  • Knotting spheres in the 4th dimension (\(\mathbb{M}\)). 4-minute video by Henry Segerman that combines 3d printing with the 2d drawing conventions of 1d knots in 3d, to make 3d knot diagrams of 2d knots in 4d.

  • On the statistics of close multiway elections (\(\mathbb{M}\)), using the recent Mississippi US Senate race as an example.

  • All 1665 submissions to STOC 2027, online (\(\mathbb{M}\)) following STOC’s new procedure of publication first, verdict afterwards.

  • Catherine Holloway explains her uncle David Huffman’s work on the mathematics of origami (\(\mathbb{M}\)). 21-minute YouTube talk.

  • Inscribed zonotopes, simplicial arrangements, and reflection groups (\(\mathbb{M}\)), Sebastian Manecke and Raman Sanyal. These are an unusual class of special zonotopes all of whose vertices belong to a sphere, in 17 combinatorial types, several of which are animated in the Mastodon thread. The planar equivalent, zonotopal tilings in which all faces are inscribed in circles, turn out to be dual to simplicial arrangements.

By David Eppstein

More podcasts, conversations, talks

from Scott Aaronson

Here’s my talk “Are We Cooked?” about the AI Mathocalypse—the one where, every time I give it, I need to update it with all the big theorems AI has proved since the last time I gave the talk. This version is from the Institute for Foundations of Machine Learning (IFML) here at UT Austin, back […]

Here’s my talk “Are We Cooked?” about the AI Mathocalypse—the one where, every time I give it, I need to update it with all the big theorems AI has proved since the last time I gave the talk. This version is from the Institute for Foundations of Machine Learning (IFML) here at UT Austin, back on October 2 (so, ancient times).

Here I am with Rabbi Neil Blumofe of Agudas Achim synagogue in Austin. Rabbi Blumofe asks me about quantum mechanics, AI, consciousness, free will, why I say “please” and “thank you” to GPT, and why I blog about Israel. The questions from the audience, unexpectedly, were more like “will cryptocurrencies that use RSA or Diffie-Hellman take longer to break with quantum computers than those that use elliptic curve cryptography?” Thanks to Rabbi Blumofe for doing this.

And here’s a podcast with Yu Shen, with Chinese subtitles. I haven’t watched this one and don’t remember what we talked about. (Oh — looking at the title graphic, apparently we talked about when AI will solve the P vs NP problem?)

By Scott

TR26-318 | Separations with Immunity Relative to a Random Oracle in Computational Complexity | Gabriel Istrate

from ECCC Papers

Rossman, Servedio, and Tan proved that the polynomial hierarchy is infinite relative to a random oracle. This paper strengthens this celebrated result by considering strong separations, witnessed by immune languages. The main result of the paper shows that with respect to a random oracle the levels of the polynomial hierarchy separate with immunity. Specifically, with probability one over a random oracle $A$, for every $k\geq 1$ there is a language in $\Sigma_{k}^{P,A}$ that is immune to $\Pi_{k}^{P,A}$, and, symmetrically, a language in $\Pi_{k}^{P,A}$ that is immune to $\Sigma_{k}^{P,A}$. We thus extend classical results due to Bennett and Gill and Vereshchagin. We accomplish this by developing a "rare-or-wrong" approach to strong separations. We highlight the flexibility of the approach by strengthening other separations with respect to a random oracle from the complexity-theoretic literature.
Rossman, Servedio, and Tan proved that the polynomial hierarchy is infinite relative to a random oracle. This paper strengthens this celebrated result by considering strong separations, witnessed by immune languages. The main result of the paper shows that with respect to a random oracle the levels of the polynomial hierarchy separate with immunity. Specifically, with probability one over a random oracle $A$, for every $k\geq 1$ there is a language in $\Sigma_{k}^{P,A}$ that is immune to $\Pi_{k}^{P,A}$, and, symmetrically, a language in $\Pi_{k}^{P,A}$ that is immune to $\Sigma_{k}^{P,A}$. We thus extend classical results due to Bennett and Gill and Vereshchagin. We accomplish this by developing a "rare-or-wrong" approach to strong separations. We highlight the flexibility of the approach by strengthening other separations with respect to a random oracle from the complexity-theoretic literature.

A More Impressive Use of AI than Proving the Unique Game Conjecture

from Computational Complexity

 I have a website devoted to parodies of the song

               I am the very model of a modern major general 

here. So I sometimes look around the web for more.  I recently came across

                                We are the very models of the throwback starfleet criminals

here. The tune isn't really the tune of I am...general but it's very impressive, especially to someone over 60 who both knows Star Trek and does not know what technology can do. 

a) It is NOT sung by fans in costume. (More on that later.)  It's actually sung by the actors who played those roles, in the costumes they wore for the show. What's really impressive is that all of the actors are dead.

b) The images looked just like the characters, and the voices sounded just like the characters.

c) I assume AI was involved. How much? Did AI write the song? Do I care so long as it's funny?

d) My main point: this would have been impossible X years ago for some value of X (readers--what do you think X is?) and hence I am impressed.  How old do you have to be to keep being impressed by these things?  And when will it stop being impressive?  Lance had a blog post about impressive visual effects in movies becoming standard and hence not impressive, see here.

e) It was really very good! Of course, as a fan of novelty songs, Gilbert and Sullivan, and Star Trek, I am predisposed to like it.

f) To understand the entire song you need to have watched three specific episodes recently.  This reminds me of a prior post see here about technology making it possible to produce good songs about niche topics. 

After seeing that video, I looked around for more Star Trek songs.  I found quite a few, here are my favorites:

------------------------------

A song about Dr. McCoy to the tune of The Devil went down to Georgia.The song's title is I'm a doctor not a ...  It's here

A song about Miles O'Brien (ST:DSN), to the tune of  I'm Gonna Be (500 miles).  The song's title is  I would fix 500 faults. It's here. I'm impressed with the video and with anyone who can identify every episode it refers to. 
A song about Picard trying to talk to a Tamarian, a species that only talks in metaphor, to the tune of Walk like an Egyptian. The song's title is Talk like a Tamarian. It's here.  It's based on one episode, Darmok. That's niche!
A song about the episode of Shore Leave from ST-TOS, to the tune of Life in Wartime.  The song's title is Life During Shore Team. It's here


----------------------------------So, AI is producing really good star trek music videos with the actors from the show singing and playing instruments (I know it's not really them but it the images are just like them.) Is there a downside? For me, as a fan, this is great. 
But there are also YouTube videos made by fans (I presume they are fans) playing the roles. So they don't look like the characters, the songs aren't as clever as the AI-generated material (there are probably exceptions). I am sure it's still FUN for them. But will they stop doing it and have AI do it for them? If so then have we, as a culture, lost something?  More generally, if writers depend too much on AI we may lose the ability as a society to produce original material. And past some point AI might run out of material to use.
Here are some fan-produced music videos:
Lets Get Logical

Oh what a fight

Hit it Warp Five This one is based on ST-SNW. Contrast: ST-TOS was on TV in the 1960's when there were a very limited number of channels. ST-SNW is on Paramount+ which you either need to pay for or watch at your mom's house and your nephew's house (that's what I do) so there just aren't that many people watching. Hence this song may win the award for most niche. And niche wins the award for word-of-the-day. 



By gasarch

 I have a website devoted to parodies of the song

               I am the very model of a modern major general 

here. So I sometimes look around the web for more.  I recently came across

                                We are the very models of the throwback starfleet criminals

here. The tune isn't really the tune of I am...general but it's very impressive, especially to someone over 60 who both knows Star Trek and does not know what technology can do. 

a) It is NOT sung by fans in costume. (More on that later.)  It's actually sung by the actors who played those roles, in the costumes they wore for the show. What's really impressive is that all of the actors are dead.

b) The images looked just like the characters, and the voices sounded just like the characters.

c) I assume AI was involved. How much? Did AI write the song? Do I care so long as it's funny?

d) My main point: this would have been impossible X years ago for some value of X (readers--what do you think X is?) and hence I am impressed.  How old do you have to be to keep being impressed by these things?  And when will it stop being impressive?  Lance had a blog post about impressive visual effects in movies becoming standard and hence not impressive, see here.

e) It was really very good! Of course, as a fan of novelty songs, Gilbert and Sullivan, and Star Trek, I am predisposed to like it.

f) To understand the entire song you need to have watched three specific episodes recently.  This reminds me of a prior post see here about technology making it possible to produce good songs about niche topics. 

After seeing that video, I looked around for more Star Trek songs.  I found quite a few, here are my favorites:

------------------------------

A song about Dr. McCoy to the tune of The Devil went down to Georgia.The song's title is I'm a doctor not a ...  It's here

A song about Miles O'Brien (ST:DSN), to the tune of  I'm Gonna Be (500 miles).  The song's title is  I would fix 500 faults. It's here. I'm impressed with the video and with anyone who can identify every episode it refers to. 

A song about Picard trying to talk to a Tamarian, a species that only talks in metaphor, to the tune of Walk like an Egyptian. The song's title is Talk like a Tamarian. It's here.  It's based on one episode, Darmok. That's niche!

A song about the episode of Shore Leave from ST-TOS, to the tune of Life in Wartime.  The song's title is Life During Shore Team. It's here



----------------------------------
So, AI is producing really good star trek music videos with the actors from the show singing and playing instruments (I know it's not really them but it the images are just like them.) Is there a downside? For me, as a fan, this is great. 

But there are also YouTube videos made by fans (I presume they are fans) playing the roles. So they don't look like the characters, the songs aren't as clever as the AI-generated material (there are probably exceptions). I am sure it's still FUN for them. But will they stop doing it and have AI do it for them? If so then have we, as a culture, lost something?  More generally, if writers depend too much on AI we may lose the ability as a society to produce original material. And past some point AI might run out of material to use.

Here are some fan-produced music videos:

Lets Get Logical

Oh what a fight

Hit it Warp Five This one is based on ST-SNW. Contrast: ST-TOS was on TV in the 1960's when there were a very limited number of channels. ST-SNW is on Paramount+ which you either need to pay for or watch at your mom's house and your nephew's house (that's what I do) so there just aren't that many people watching. Hence this song may win the award for most niche. And niche wins the award for word-of-the-day. 



By gasarch

Friday, November 13

Winter School on Cryptography and Machine Learning

from CS Theory Events

January 25-28, 2027 Bocconi University, Milan, Italy bidsa.unibocconi.eu/cryptography-and-machine-learning-2027-winter-school AI systems are now deployed at scale, yet we have very few rigorous guarantees about their security, privacy and safety. For decades, cryptography has developed the tools to reason formally about adversarial behaviour and to prove security against it. Many pressing questions about modern AI are, at … Continue reading Winter School on Cryptography and Machine Learning

By shacharlovett

January 25-28, 2027 Bocconi University, Milan, Italy https://bidsa.unibocconi.eu/cryptography-and-machine-learning-2027-winter-school AI systems are now deployed at scale, yet we have very few rigorous guarantees about their security, privacy and safety. For decades, cryptography has developed the tools to reason formally about adversarial behaviour and to prove security against it. Many pressing questions about modern AI are, at … Continue reading Winter School on Cryptography and Machine Learning

By shacharlovett

PhD position in Complexity Theory at Georgia Tech (Atlanta, USA) (apply by December 15, 2026)

from CCI: jobs

A PhD position in complexity theory is available in the Theory Group at Georgia Tech’s School of Computer Science. Interested candidates should apply to one of the relevant PhD programs by 15 December 2026. Website: scs.gatech.edu/phd-programs Email: igorcarb@gmail.com

A PhD position in complexity theory is available in the Theory Group at Georgia Tech’s School of Computer Science. Interested candidates should apply to one of the relevant PhD programs by 15 December 2026.

Website: https://scs.gatech.edu/phd-programs
Email: igorcarb@gmail.com

By shacharlovett

Postdoc position in Complexity Theory at Georgia Tech (Atlanta, USA) (apply by December 1, 2026)

from CCI: jobs

Please see the call at the Algorithms and Randomness Center (ARC) and apply by 1 December 2026 for full consideration. Applications will be considered until the positions are filled. Website: arc.gatech.edu/postdocs/ Email: igorcarb@gmail.com

Please see the call at the Algorithms and Randomness Center (ARC) and apply by 1 December 2026 for full consideration. Applications will be considered until the positions are filled.

Website: https://arc.gatech.edu/postdocs/
Email: igorcarb@gmail.com

By shacharlovett

The Tournament Equilibrium Set Is PSPACE-Complete, Even under Hereditary Uniqueness

from arXiv: Computational Complexity

Authors: Ethan Dickey, Athina Terzoglou

The tournament equilibrium set (TEQ), proposed by Schwartz in 1990, is a classical voting rule based on pairwise majority comparisons. Its definition is recursive: an alternative is judged by the alternatives that beat it, called its dominators, and by which of those dominators TEQ itself selects. Deciding whether a given alternative belongs to TEQ was known to be NP-hard and to lie in PSPACE. We close this gap by proving that the problem is PSPACE-complete. To our knowledge, this is the first PSPACE-completeness result for membership in a tournament solution. The hardness persists even when every nonempty subtournament has a unique minimal retentive set, the property conjectured by Schwartz to hold for all tournaments. Moreover, every such subtournament in our hard instances contains an alternative with at most three dominators. We prove that a single alternative with at most four dominators suffices both to guarantee uniqueness and to find a TEQ winner in $O(N^2)$ time. Thus, on our hard instances, finding one winner is efficient even though recognizing a specified winner is PSPACE-complete. We also study how the complexity changes with the dominator bound. If every nonempty subtournament has an alternative with at most one dominator, the entire TEQ can be computed in quadratic time; allowing two dominators makes membership NP-hard. Under the same condition with four dominators, all $t$ winners can be computed in $O(2^t N^2)$ time, where $N$ is the number of alternatives.

Authors: Ethan Dickey, Athina Terzoglou

The tournament equilibrium set (TEQ), proposed by Schwartz in 1990, is a classical voting rule based on pairwise majority comparisons. Its definition is recursive: an alternative is judged by the alternatives that beat it, called its dominators, and by which of those dominators TEQ itself selects. Deciding whether a given alternative belongs to TEQ was known to be NP-hard and to lie in PSPACE. We close this gap by proving that the problem is PSPACE-complete. To our knowledge, this is the first PSPACE-completeness result for membership in a tournament solution. The hardness persists even when every nonempty subtournament has a unique minimal retentive set, the property conjectured by Schwartz to hold for all tournaments. Moreover, every such subtournament in our hard instances contains an alternative with at most three dominators. We prove that a single alternative with at most four dominators suffices both to guarantee uniqueness and to find a TEQ winner in $O(N^2)$ time. Thus, on our hard instances, finding one winner is efficient even though recognizing a specified winner is PSPACE-complete. We also study how the complexity changes with the dominator bound. If every nonempty subtournament has an alternative with at most one dominator, the entire TEQ can be computed in quadratic time; allowing two dominators makes membership NP-hard. Under the same condition with four dominators, all $t$ winners can be computed in $O(2^t N^2)$ time, where $N$ is the number of alternatives.

Sowing the Seeds of Intractability: Kalah is PSPACE-complete

from arXiv: Computational Complexity

Authors: Ethan Dickey, Ethan Mader

Kalah is a classic two-player game in the mancala family of sowing games. Computers have solved several standard-size starting positions, but the complexity of the game on boards of growing size has remained open. We study the natural generalization in which the number of pits per side is part of the input and an arbitrary position is given, with the stone counts given in unary. We show that deciding whether a designated player can force a win from such a position is PSPACE-complete. The hard positions have Alice to move first and both stores initially empty. The same positions are hard under either common convention for capture opposite an empty pit, and with or without the bonus rule, which gives a player another turn when the last stone is sown into their own store. We introduce Line Kalah as an intermediate problem, a game on a line in which stones that leave the line effectively disappear and Alice must save each of her target pits before Bob captures it, and we reduce quantified Boolean formulas to it. The reduction uses a set of sequential timer piles whose last stones approach a group of targets, forcing Alice to choose between two captures in order to set the truth value of a variable, and a final capture gadget to test a clause chosen by Bob (only one is needed adversarially). Since either player may move any pile at any time, the stages are placed so that premature timer firings protect earlier potential targets. For a true formula, Alice's strategy against arbitrary opposing play either gains enough time to save the remaining targets (after Bob deviates from the intended play) or reaches the final test with a correctly encoded, protected input. Finally, the line positions are embedded in Kalah with both stores empty. A separate Bob pit holds the score adjustment, so the winner takes a strict majority of the stones.

Authors: Ethan Dickey, Ethan Mader

Kalah is a classic two-player game in the mancala family of sowing games. Computers have solved several standard-size starting positions, but the complexity of the game on boards of growing size has remained open. We study the natural generalization in which the number of pits per side is part of the input and an arbitrary position is given, with the stone counts given in unary. We show that deciding whether a designated player can force a win from such a position is PSPACE-complete. The hard positions have Alice to move first and both stores initially empty. The same positions are hard under either common convention for capture opposite an empty pit, and with or without the bonus rule, which gives a player another turn when the last stone is sown into their own store. We introduce Line Kalah as an intermediate problem, a game on a line in which stones that leave the line effectively disappear and Alice must save each of her target pits before Bob captures it, and we reduce quantified Boolean formulas to it. The reduction uses a set of sequential timer piles whose last stones approach a group of targets, forcing Alice to choose between two captures in order to set the truth value of a variable, and a final capture gadget to test a clause chosen by Bob (only one is needed adversarially). Since either player may move any pile at any time, the stages are placed so that premature timer firings protect earlier potential targets. For a true formula, Alice's strategy against arbitrary opposing play either gains enough time to save the remaining targets (after Bob deviates from the intended play) or reaches the final test with a correctly encoded, protected input. Finally, the line positions are embedded in Kalah with both stores empty. A separate Bob pit holds the score adjustment, so the winner takes a strict majority of the stones.

Computation with Backward Feedback: Power, Observation, and Cost

from arXiv: Computational Complexity

Authors: Saman Farhat, Farzad Didehvar

How much can a computation gain by passing information back to an earlier stage, and how soon can an observer obtain the answer? We study deterministic programs whose runs are accessed at randomly selected stages. A program keeps a register, a finite block of memory. A random clock selects the current stage; each tick takes a random step, with a law fixed independently of input, program and register. When the clock moves backward, the register contents at the stage it leaves start a new run, and the clock continues where it lands. Equilibrium readout requires a distribution of clock position and register that one tick leaves unchanged, and a correct final answer under every such distribution. For bounded steps in both directions with negative average, we obtain an exact classification at each polynomial scale s. If running time and register length are both O(s), feedback gives exactly nondeterministic space O(s); without transmission the class is deterministic time O(s), which is strictly smaller. An observer that starts at stage zero with an all-zero register, reads sequentially and never accepts a nonmember sees, with fewer ticks than any exponential, only languages fixed by a bounded input prefix. Exponentially many ticks reveal every linear-time language. For a clock moving one step up or down, we bound the wait for useful backward moves and the rate of random erasures a stored counter tolerates. The results separate the power of feedback at equilibrium, observation from a fixed start, and the cost of obtaining and keeping information.

Authors: Saman Farhat, Farzad Didehvar

How much can a computation gain by passing information back to an earlier stage, and how soon can an observer obtain the answer? We study deterministic programs whose runs are accessed at randomly selected stages. A program keeps a register, a finite block of memory. A random clock selects the current stage; each tick takes a random step, with a law fixed independently of input, program and register. When the clock moves backward, the register contents at the stage it leaves start a new run, and the clock continues where it lands. Equilibrium readout requires a distribution of clock position and register that one tick leaves unchanged, and a correct final answer under every such distribution. For bounded steps in both directions with negative average, we obtain an exact classification at each polynomial scale s. If running time and register length are both O(s), feedback gives exactly nondeterministic space O(s); without transmission the class is deterministic time O(s), which is strictly smaller. An observer that starts at stage zero with an all-zero register, reads sequentially and never accepts a nonmember sees, with fewer ticks than any exponential, only languages fixed by a bounded input prefix. Exponentially many ticks reveal every linear-time language. For a clock moving one step up or down, we bound the wait for useful backward moves and the rate of random erasures a stored counter tolerates. The results separate the power of feedback at equilibrium, observation from a fixed start, and the cost of obtaining and keeping information.

Topological Entropy of Group Cellular Automata is Effectively Computable

from arXiv: Computational Complexity

Authors: Niccolò Castronuovo, Alberto Dennunzio, Jarkko Kari, Luciano Margara

Topological entropy is a fundamental invariant of dynamical systems, quantifying their complexity. For cellular automata, however, determining topological entropy is generally algorithmically intractable. We study group cellular automata, namely cellular automata over a finite group alphabet whose global map is a group endomorphism. In dimension one, we decompose topological entropy into two one-sided components describing information propagating from the left and from the right in space--time. We introduce finite families of left and right traces and prove that the entropy is the sum of their growth rates. Hence, the entropy is completely determined by the growth rate of a fixed-width family of space--time patterns. This reduction from arbitrarily large windows to uniformly bounded width yields an effective procedure for computing the entropy. In particular, the entropy of every one-dimensional group cellular automaton is the logarithm of a positive integer. Using Pontryagin duality and the Bridge Theorem between topological and algebraic entropy, we also derive an explicit formula for linear cellular automata over $(\mathbb{Z}/p\mathbb{Z})^n$ in terms of their characteristic polynomial. Moreover, in every dimension $D\geq 2$, a group cellular automaton is either equicontinuous with zero entropy or sensitive to initial conditions with infinite entropy. Combined with decidability of equicontinuity, this implies that topological entropy is effectively computable from the local rule in every dimension. Thus, group cellular automata form a natural nontrivial class in which algebraic structure restores computability of topological entropy.

Authors: Niccolò Castronuovo, Alberto Dennunzio, Jarkko Kari, Luciano Margara

Topological entropy is a fundamental invariant of dynamical systems, quantifying their complexity. For cellular automata, however, determining topological entropy is generally algorithmically intractable. We study group cellular automata, namely cellular automata over a finite group alphabet whose global map is a group endomorphism. In dimension one, we decompose topological entropy into two one-sided components describing information propagating from the left and from the right in space--time. We introduce finite families of left and right traces and prove that the entropy is the sum of their growth rates. Hence, the entropy is completely determined by the growth rate of a fixed-width family of space--time patterns. This reduction from arbitrarily large windows to uniformly bounded width yields an effective procedure for computing the entropy. In particular, the entropy of every one-dimensional group cellular automaton is the logarithm of a positive integer. Using Pontryagin duality and the Bridge Theorem between topological and algebraic entropy, we also derive an explicit formula for linear cellular automata over $(\mathbb{Z}/p\mathbb{Z})^n$ in terms of their characteristic polynomial. Moreover, in every dimension $D\geq 2$, a group cellular automaton is either equicontinuous with zero entropy or sensitive to initial conditions with infinite entropy. Combined with decidability of equicontinuity, this implies that topological entropy is effectively computable from the local rule in every dimension. Thus, group cellular automata form a natural nontrivial class in which algebraic structure restores computability of topological entropy.

Exact Quantum Algorithms for Composed Boolean Functions

from arXiv: Computational Complexity

Authors: Gagan Chiruvella, Chandrima Kayal, Rajat Mittal, Manaswi Paraashar, Nitin Saurabh

We study exact quantum algorithms for block compositions of total Boolean functions. For an outer function $f$ of degree $D$ and an inner function $g$ on $m$ bits, we prove $$ Q_E(f\circ g)=O\!\left(mD+Q_E(f)Q_{1/(4D)}(g)\right). $$ The algorithm combines approximate inner evaluations with a finite exact correction. Its two costs are governed by different parameters of the outer function: exact query complexity determines the cost of simulation, whereas polynomial degree determines the number of inner blocks used in the correction. We first establish the construction with an arity-dependent error threshold and then obtain the degree-dependent threshold above. For recursive ternary not-all-equal, this gives an exact algorithm using $(3/\sqrt2)^{k(1+o(1))}$ queries asymptotically. More generally, for every fixed nonconstant total gadget $h$, we determine the exact recursive rate as $\max\{\textrm{deg}(h),\operatorname{Adv}^{\pm}(h)\}$ and prove $Q_E(h^{\circ k})=\widetilde O_h(R(h^{\circ k})^2)$. The composition limit also allows to transfer separations from $Q_{\varepsilon}$ and $°$ to exact quantum query complexity $Q_E$ (similar to fractional block sensitivity to block sensitivity transfer in Tal and Kulkarni 2016, Chicago Journal of Theoretical Computer Science). We construct a family with $s=\operatorname{bs}=\operatorname{fbs}\ge Q_E^{3/2-o(1)}$, improving the previous exponent $1.1527\ldots$. A second construction gives $R \ge Q_E^{2-o(1)}$, improving the previous exponent $3/2$. We also allow different inner functions and give analogous quantitative separations in quantum communication.

Authors: Gagan Chiruvella, Chandrima Kayal, Rajat Mittal, Manaswi Paraashar, Nitin Saurabh

We study exact quantum algorithms for block compositions of total Boolean functions. For an outer function $f$ of degree $D$ and an inner function $g$ on $m$ bits, we prove $$ Q_E(f\circ g)=O\!\left(mD+Q_E(f)Q_{1/(4D)}(g)\right). $$ The algorithm combines approximate inner evaluations with a finite exact correction. Its two costs are governed by different parameters of the outer function: exact query complexity determines the cost of simulation, whereas polynomial degree determines the number of inner blocks used in the correction. We first establish the construction with an arity-dependent error threshold and then obtain the degree-dependent threshold above. For recursive ternary not-all-equal, this gives an exact algorithm using $(3/\sqrt2)^{k(1+o(1))}$ queries asymptotically. More generally, for every fixed nonconstant total gadget $h$, we determine the exact recursive rate as $\max\{\textrm{deg}(h),\operatorname{Adv}^{\pm}(h)\}$ and prove $Q_E(h^{\circ k})=\widetilde O_h(R(h^{\circ k})^2)$. The composition limit also allows to transfer separations from $Q_{\varepsilon}$ and $°$ to exact quantum query complexity $Q_E$ (similar to fractional block sensitivity to block sensitivity transfer in Tal and Kulkarni 2016, Chicago Journal of Theoretical Computer Science). We construct a family with $s=\operatorname{bs}=\operatorname{fbs}\ge Q_E^{3/2-o(1)}$, improving the previous exponent $1.1527\ldots$. A second construction gives $R \ge Q_E^{2-o(1)}$, improving the previous exponent $3/2$. We also allow different inner functions and give analogous quantitative separations in quantum communication.

Weak Composition Theorems for Randomized Communication

from arXiv: Computational Complexity

Authors: Pachara Sawettamalya

We present two results towards the randomized communication complexity of composed functions. Our contributions include: - \textbf{Lifting-by-Influence.} For any binary function $f$ and any outer gadget $g:\{0,1\}^n \rightarrow \mathbb{R}$, we show that up to additive terms, computing $g \circ f^n$ information-theoretically requires solving at least $\operatorname{Inf}(g)$ instances of $f$, where $\operatorname{Inf}(g)$ denotes the total influence of $g$. To our knowledge, this is the first composition lower bound for randomized communication that applies to \emph{every} choice of $f$ and $g$. - \textbf{Symmetric Composition.} When $g$ is a symmetric function with a value transition at Hamming weight $d$, we strengthen the number of required instances to $\min\{d,n+1-d\}$. As an implication, this recovers the previously known direct-sum theorem, XOR lemma, and majority lemma. Our proofs develop novel and distinctive usages of the classical \emph{input embedding} argument of Barak, Braverman, Chen, and Rao (SICOMP 2013). As an additional ingredient, we introduce a new public sampling framework that avoids auxiliary communication during the recovery phase of the protocol, ultimately reducing the extra cost from $O(n)$ bits of information to just $O(1)$.

Authors: Pachara Sawettamalya

We present two results towards the randomized communication complexity of composed functions. Our contributions include: - \textbf{Lifting-by-Influence.} For any binary function $f$ and any outer gadget $g:\{0,1\}^n \rightarrow \mathbb{R}$, we show that up to additive terms, computing $g \circ f^n$ information-theoretically requires solving at least $\operatorname{Inf}(g)$ instances of $f$, where $\operatorname{Inf}(g)$ denotes the total influence of $g$. To our knowledge, this is the first composition lower bound for randomized communication that applies to \emph{every} choice of $f$ and $g$. - \textbf{Symmetric Composition.} When $g$ is a symmetric function with a value transition at Hamming weight $d$, we strengthen the number of required instances to $\min\{d,n+1-d\}$. As an implication, this recovers the previously known direct-sum theorem, XOR lemma, and majority lemma. Our proofs develop novel and distinctive usages of the classical \emph{input embedding} argument of Barak, Braverman, Chen, and Rao (SICOMP 2013). As an additional ingredient, we introduce a new public sampling framework that avoids auxiliary communication during the recovery phase of the protocol, ultimately reducing the extra cost from $O(n)$ bits of information to just $O(1)$.

The Ultimate Karp-Lipton Collapse

from arXiv: Computational Complexity

Authors: Edward A. Hirsch, Ilya Volkovich

Karp and Lipton proved that if $NP\subseteq P/poly$, then $PH$ collapses. A long line of work pushed the collapse to smaller classes. In particular, Chakaravarthy and Roy obtained two such collapses, to (apparently) incomparable classes $O_2^P$ and $P^{prMA}$. We united them earlier by a collapse to the input-oblivious version $P^{prOMA}$ of $P^{prMA}$, which is contained in both; and, jointly with Williams, to a slightly smaller class. Two other deepest known collapses are to $ZPP^{ONP}$ (following from Köbler and Watanabe) and to $OL_2^P$ (proved in this paper). We unite the three collapses by a collapse to a class contained in all of them. We use a three-stage computational model OGTD (oblivious generator-tester-decoder): a polynomial-time generator with an oracle computes an advice string from $1^n$, a tester certifies it, and a polynomial-time decoder uses it (it is the only one that sees the actual input). Let $OM$ be the class of OGTD languages defined by a restricted version of $prOMA$ as the generator's oracle, by a co-$ONP$ tester, and a $P$ decoder. We show that it is contained in the three collapse classes above and prove that $PH$ collapses to $OM$ under $NP\subseteq P/poly$. The collapse also holds for an unambiguous version of $OM$. All these input-oblivious collapse classes lie in $P^{prSBP}$, and so do even the non-input-oblivious versions $P^{prMA}$, $L_2^P$ and $S_2^P$: we prove that $P^{prS_2^P}\subseteq P^{prSBP}$. This strengthens the containment $S_2^P\subseteq P^{prAM}$ of Chakaravarthy and Roy and our earlier containment $L_2^P\subseteq P^{prSBP}$. The proof unites the Goldreich-Wigderson-type procedure of Chakaravarthy and Roy with our earlier approximate-counting technique. Its input-oblivious counterpart concerns $O_2^P$, the first collapse class of Chakaravarthy and Roy: every language in $O_2^P$ has polynomial-size circuits constructible in $FP^{prSBP}$.

Authors: Edward A. Hirsch, Ilya Volkovich

Karp and Lipton proved that if $NP\subseteq P/poly$, then $PH$ collapses. A long line of work pushed the collapse to smaller classes. In particular, Chakaravarthy and Roy obtained two such collapses, to (apparently) incomparable classes $O_2^P$ and $P^{prMA}$. We united them earlier by a collapse to the input-oblivious version $P^{prOMA}$ of $P^{prMA}$, which is contained in both; and, jointly with Williams, to a slightly smaller class. Two other deepest known collapses are to $ZPP^{ONP}$ (following from Köbler and Watanabe) and to $OL_2^P$ (proved in this paper). We unite the three collapses by a collapse to a class contained in all of them. We use a three-stage computational model OGTD (oblivious generator-tester-decoder): a polynomial-time generator with an oracle computes an advice string from $1^n$, a tester certifies it, and a polynomial-time decoder uses it (it is the only one that sees the actual input). Let $OM$ be the class of OGTD languages defined by a restricted version of $prOMA$ as the generator's oracle, by a co-$ONP$ tester, and a $P$ decoder. We show that it is contained in the three collapse classes above and prove that $PH$ collapses to $OM$ under $NP\subseteq P/poly$. The collapse also holds for an unambiguous version of $OM$. All these input-oblivious collapse classes lie in $P^{prSBP}$, and so do even the non-input-oblivious versions $P^{prMA}$, $L_2^P$ and $S_2^P$: we prove that $P^{prS_2^P}\subseteq P^{prSBP}$. This strengthens the containment $S_2^P\subseteq P^{prAM}$ of Chakaravarthy and Roy and our earlier containment $L_2^P\subseteq P^{prSBP}$. The proof unites the Goldreich-Wigderson-type procedure of Chakaravarthy and Roy with our earlier approximate-counting technique. Its input-oblivious counterpart concerns $O_2^P$, the first collapse class of Chakaravarthy and Roy: every language in $O_2^P$ has polynomial-size circuits constructible in $FP^{prSBP}$.

Polynomial Swap Coboundary Expansion with Applications to LTCs and PCPs

from arXiv: Computational Complexity

Authors: Yotam Dikstein, Izhar Oppenheim, Inga Valentiner-Branth

Swap coboundary expansion, introduced independently by Bafna--Minzer and Dikstein--Dinur, is a local-to-global property that underlies agreement tests in the low-acceptance regime and recent constructions of succinct PCPs. Previous works obtained bounds of $\exp(-O(\sqrt{r}))$ for the $r$-swap coboundary expansion of Chapman--Lubotzky complexes. We establish the first inverse-polynomial bounds for bounded-degree complexes: suitable skeleta of Kac--Moody--Steinberg (KMS) complexes have $r$-swap coboundary expansion at least $r^{-O(1)}$. Our theorem supplies a key ingredient in forthcoming work of Ben Yaacov--Dikstein--Liu, which obtains local tests for sparse algebraic codes with guarantees even at arbitrarily small acceptance probability. These tests use $\exp(\operatorname{poly}(1/\varepsilon))$ queries and guarantee that any word accepted with probability at least $\varepsilon$ agrees with a codeword on an $\varepsilon^{O(1)}$ fraction of coordinates. Separately, substituting our bound into the existing analysis of Bafna--Minzer--Vyas--Yun improves the soundness dependence of their two-query PCP construction, giving perfect completeness, soundness $\varepsilon$, and proof length $n(\log n)^{\exp(\operatorname{poly}(1/\varepsilon))}$. Our proof exploits the product structure of the groups arising in KMS complexes. The main new ingredient is a decomposition lemma for Dehn functions, which separates the analysis of group relations into independent problems on much smaller factors, with only polynomial overhead.

Authors: Yotam Dikstein, Izhar Oppenheim, Inga Valentiner-Branth

Swap coboundary expansion, introduced independently by Bafna--Minzer and Dikstein--Dinur, is a local-to-global property that underlies agreement tests in the low-acceptance regime and recent constructions of succinct PCPs. Previous works obtained bounds of $\exp(-O(\sqrt{r}))$ for the $r$-swap coboundary expansion of Chapman--Lubotzky complexes. We establish the first inverse-polynomial bounds for bounded-degree complexes: suitable skeleta of Kac--Moody--Steinberg (KMS) complexes have $r$-swap coboundary expansion at least $r^{-O(1)}$. Our theorem supplies a key ingredient in forthcoming work of Ben Yaacov--Dikstein--Liu, which obtains local tests for sparse algebraic codes with guarantees even at arbitrarily small acceptance probability. These tests use $\exp(\operatorname{poly}(1/\varepsilon))$ queries and guarantee that any word accepted with probability at least $\varepsilon$ agrees with a codeword on an $\varepsilon^{O(1)}$ fraction of coordinates. Separately, substituting our bound into the existing analysis of Bafna--Minzer--Vyas--Yun improves the soundness dependence of their two-query PCP construction, giving perfect completeness, soundness $\varepsilon$, and proof length $n(\log n)^{\exp(\operatorname{poly}(1/\varepsilon))}$. Our proof exploits the product structure of the groups arising in KMS complexes. The main new ingredient is a decomposition lemma for Dehn functions, which separates the analysis of group relations into independent problems on much smaller factors, with only polynomial overhead.

Sheaf-Inspired Structured Scoring Extensions of LightGCN for Collaborative Filtering

from arXiv: Computational Geometry

Authors: Ksenia Belkovskaya, Timur Lidzhiev, Maria Stebliy, Alexander Tarakanov

Graph-based collaborative filtering learns user and item representations by propagating embeddings over a user--item interaction graph. We investigate a modular, sheaf-inspired scoring extension placed on top of a three-layer LightGCN backbone. The motivation comes from cellular sheaves, where local vector spaces are related by linear restriction maps; here, this idea motivates structured, pair-dependent transformations of user and item embeddings rather than a change to graph propagation. We compare the identity inner-product scorer, diagonal, rank-one low-rank, and full matrix residual scorers, and a parameter-matched residual MLP baseline (\texttt{mlp\_full}) on Amazon-Book, Gowalla, MovieLens-1M, and Yelp2018. We report ranking quality and catalog coverage at cutoffs 10 and 20. The selected structured variants show modest, dataset-dependent changes in ranking quality and sometimes substantial changes in coverage. Our method is inspired by sheaf geometry but does not construct a cellular sheaf or implement sheaf-Laplacian diffusion; the experiments therefore do not establish a causal benefit from sheaf geometry itself.

Authors: Ksenia Belkovskaya, Timur Lidzhiev, Maria Stebliy, Alexander Tarakanov

Graph-based collaborative filtering learns user and item representations by propagating embeddings over a user--item interaction graph. We investigate a modular, sheaf-inspired scoring extension placed on top of a three-layer LightGCN backbone. The motivation comes from cellular sheaves, where local vector spaces are related by linear restriction maps; here, this idea motivates structured, pair-dependent transformations of user and item embeddings rather than a change to graph propagation. We compare the identity inner-product scorer, diagonal, rank-one low-rank, and full matrix residual scorers, and a parameter-matched residual MLP baseline (\texttt{mlp\_full}) on Amazon-Book, Gowalla, MovieLens-1M, and Yelp2018. We report ranking quality and catalog coverage at cutoffs 10 and 20. The selected structured variants show modest, dataset-dependent changes in ranking quality and sometimes substantial changes in coverage. Our method is inspired by sheaf geometry but does not construct a cellular sheaf or implement sheaf-Laplacian diffusion; the experiments therefore do not establish a causal benefit from sheaf geometry itself.

Asymptotic Dimension of Persistence Modules of Bounded Presentation

from arXiv: Computational Geometry

Authors: Sushovan Majhi, Atish Mitra, Žiga Virk

We compute the asymptotic dimension of spaces of multiparameter persistence modules of bounded presentation under the interleaving distance. The $d$-parameter modules with at most $n$ generators and $m$ relations have asymptotic dimension, and Assouad-Nagata dimension, exactly $d(n+m)$, the number of coordinates of their generator and relation grades, over every field; for two parameters this is $2(n+m)$. The space has continuous moduli, already for two parameters and $n,m\ge2$: over an infinite field it contains, at every scale, infinite uniformly separated families of pairwise non-isomorphic modules with one fibered barcode, so it is not doubling even at a fixed fibered barcode; already for $m\ge1$ it is not coarsely equivalent to a proper metric space. The proof is an induction on the number of distinct grade coordinates: an interleaving small compared with the gaps between these coordinates moves each of them by at most twice its size and preserves the induced grid representation, so the continuous moduli are invisible at large scale. Each class of modules at finite distance therefore embeds coarsely into Hilbert space; for $n,m\ge2$ over an uncountable field, the classes that contain these families admit no such embedding into a separable Hilbert space. Under the two-parameter matching distance $2(n+m)$ is a lower bound, attained for one generator and for two generators with at most one relation; on a finite net of $S$ slices the asymptotic dimension is at most $2nS$.

Authors: Sushovan Majhi, Atish Mitra, Žiga Virk

We compute the asymptotic dimension of spaces of multiparameter persistence modules of bounded presentation under the interleaving distance. The $d$-parameter modules with at most $n$ generators and $m$ relations have asymptotic dimension, and Assouad-Nagata dimension, exactly $d(n+m)$, the number of coordinates of their generator and relation grades, over every field; for two parameters this is $2(n+m)$. The space has continuous moduli, already for two parameters and $n,m\ge2$: over an infinite field it contains, at every scale, infinite uniformly separated families of pairwise non-isomorphic modules with one fibered barcode, so it is not doubling even at a fixed fibered barcode; already for $m\ge1$ it is not coarsely equivalent to a proper metric space. The proof is an induction on the number of distinct grade coordinates: an interleaving small compared with the gaps between these coordinates moves each of them by at most twice its size and preserves the induced grid representation, so the continuous moduli are invisible at large scale. Each class of modules at finite distance therefore embeds coarsely into Hilbert space; for $n,m\ge2$ over an uncountable field, the classes that contain these families admit no such embedding into a separable Hilbert space. Under the two-parameter matching distance $2(n+m)$ is a lower bound, attained for one generator and for two generators with at most one relation; on a finite net of $S$ slices the asymptotic dimension is at most $2nS$.

Optimal Polyomino Fences

from arXiv: Computational Geometry

Authors: Alexis Langlois-Rémillard, Mia N. Müßig, Helmut Podhaisky, Erika Roldan, Günter Rote, Maximilian Brömme, Matthes Norden, Maximilian Prietzel, Daniel Yu, Mykhailo Lyader

The $n$-omino fence problem asks how many cells can be surrounded by placing every $n$-omino exactly once in the grid. We present a new dynamic programming approach for this problem, allowing us to prove optimality for the pentomino and hexomino fence and to classify all possible pentomino orders by optimal area. For the first time we also provide strong heuristic solutions and upper bounds for all fences up to $n = 15$, after which we even approximate the $500$-omino fence with computational experiments. Finally, we generalize the problem to 3D, where we prove optimality for pentacubes and derive heuristic solutions for hexacubes and heptacubes.

Authors: Alexis Langlois-Rémillard, Mia N. Müßig, Helmut Podhaisky, Erika Roldan, Günter Rote, Maximilian Brömme, Matthes Norden, Maximilian Prietzel, Daniel Yu, Mykhailo Lyader

The $n$-omino fence problem asks how many cells can be surrounded by placing every $n$-omino exactly once in the grid. We present a new dynamic programming approach for this problem, allowing us to prove optimality for the pentomino and hexomino fence and to classify all possible pentomino orders by optimal area. For the first time we also provide strong heuristic solutions and upper bounds for all fences up to $n = 15$, after which we even approximate the $500$-omino fence with computational experiments. Finally, we generalize the problem to 3D, where we prove optimality for pentacubes and derive heuristic solutions for hexacubes and heptacubes.

An upper bound on the number of edges of a Gomory corner polyhedron

from arXiv: Computational Geometry

Authors: A. Yu. Chirkov, S. I. Veselov, D. V. Gribanov, D. S. Malyshev, N. Yu. Zolotykh

We establish the first nontrivial upper bound on the number of edges of a Gomory corner polyhedron, resolving a long-standing open question. For an $n$-dimensional corner polyhedron associated with an integer lattice of determinant $δ$, the number of edges is at most $$ O\left(n6^n \cdot \bigl(1+\log_2(2δ)\bigr)^{2n-3}\right). $$ This improves the standard bound obtained by counting pairs of vertices, reducing the logarithmic exponent from $(2n-2)$ to $(2n-3)$.

Authors: A. Yu. Chirkov, S. I. Veselov, D. V. Gribanov, D. S. Malyshev, N. Yu. Zolotykh

We establish the first nontrivial upper bound on the number of edges of a Gomory corner polyhedron, resolving a long-standing open question. For an $n$-dimensional corner polyhedron associated with an integer lattice of determinant $δ$, the number of edges is at most $$ O\left(n6^n \cdot \bigl(1+\log_2(2δ)\bigr)^{2n-3}\right). $$ This improves the standard bound obtained by counting pairs of vertices, reducing the logarithmic exponent from $(2n-2)$ to $(2n-3)$.

Visibility graphs of irregularly sampled two-dimensional fields via Voronoi tessellations

from arXiv: Computational Geometry

Authors: Francisco J. Muñoz, Juan Carlos Nuño

Visibility graphs map a time series into a network by linking two data whenever the straight line between them is not obstructed by intermediate data. Their extension to two-dimensional fields has so far been restricted to regular lattices, where visibility is checked along a finite number of lattice directions. We propose a definition for scalar data sampled at arbitrary, irregularly scattered points of the plane. Each point is assigned its Voronoi cell, so that the data become a landscape of prisms, and two points are linked when the line of sight between them clears the cells crossed by the connecting segment. This yields horizontal ($\HVGV$) and natural ($\NVGV$) Voronoi visibility graphs that reduce exactly to the classical horizontal and natural visibility graphs when the points are collinear, contain the Gabriel graph of the point set, and can be built by an exact walk through the Delaunay triangulation. For uncorrelated heights, the horizontal graph depends only on the ranks of the data, so its statistics are independent of the marginal distribution. The probability that two points see each other is $2/[(M+1)(M+2)]$, where $M$ is the number of Voronoi cells crossed, which reduces the problem to the geometry of the tessellation. For Poisson points this gives a degree distribution with a scale-free tail $P(k)\simeq(π^3/4)\,k^{-2}$ and a mean degree that grows as $(π^3/8)\ln N$, in contrast with the finite value $\langle k\rangle=4$ of one-dimensional series. Two dimensions are therefore the marginal case in which isotropic horizontal visibility ceases to be local. Numerical simulations with up to $N=1.28\times10^5$ points support these predictions.

Authors: Francisco J. Muñoz, Juan Carlos Nuño

Visibility graphs map a time series into a network by linking two data whenever the straight line between them is not obstructed by intermediate data. Their extension to two-dimensional fields has so far been restricted to regular lattices, where visibility is checked along a finite number of lattice directions. We propose a definition for scalar data sampled at arbitrary, irregularly scattered points of the plane. Each point is assigned its Voronoi cell, so that the data become a landscape of prisms, and two points are linked when the line of sight between them clears the cells crossed by the connecting segment. This yields horizontal ($\HVGV$) and natural ($\NVGV$) Voronoi visibility graphs that reduce exactly to the classical horizontal and natural visibility graphs when the points are collinear, contain the Gabriel graph of the point set, and can be built by an exact walk through the Delaunay triangulation. For uncorrelated heights, the horizontal graph depends only on the ranks of the data, so its statistics are independent of the marginal distribution. The probability that two points see each other is $2/[(M+1)(M+2)]$, where $M$ is the number of Voronoi cells crossed, which reduces the problem to the geometry of the tessellation. For Poisson points this gives a degree distribution with a scale-free tail $P(k)\simeq(π^3/4)\,k^{-2}$ and a mean degree that grows as $(π^3/8)\ln N$, in contrast with the finite value $\langle k\rangle=4$ of one-dimensional series. Two dimensions are therefore the marginal case in which isotropic horizontal visibility ceases to be local. Numerical simulations with up to $N=1.28\times10^5$ points support these predictions.

Tight Algorithms for Conservative Finite-Valued CSPs Parameterized by Treewidth

from arXiv: Data Structures and Algorithms

Authors: Jakob Greilhuber, Dániel Marx, George Osipov, Marta Piecyk, Paweł Rzążewski, Stanislav Živný

We consider valued constraint satisfaction problems (VCSPs) with a fixed finite domain $D$ and a fixed finite constraint language $Γ$, in the setting where $Γ$ contains all crisp unary constraints (called hard lists) and the remaining cost functions are finite-valued. We call such a language a finite-valued hard-list language. Let $c_Γ$ be the size of the largest set $S\subseteq D$ such that $Γ$ can express (using the usual VCSP closure operations) a binary disequality function on elements of $S$. Our main result tightly connects the complexity of the problem parameterized by treewidth to this value $c_Γ$. (1) The problem can be solved in time $(c_Γ)^{\mathsf{tw}} \cdot (|I| + |\mathcal{T}|)^{O(1)}$ when given an instance $I$ with a tree decomposition $\mathcal{T}$ of width $\mathsf{tw}$ of the primal graph of $I$. (2) If $c_Γ\geq 2$, there is no such algorithm solving the problem in time $(c_Γ- \varepsilon)^{\mathsf{tw}} \cdot (|I| + |\mathcal{T}|)^{O(1)}$ for any $\varepsilon > 0$, unless the Primal Treewidth SETH (and hence CNF-SETH) fails. In particular, this gives a far-reaching generalization of a similar result of Esmer et al. [ESA 2024] on the optimization version of list homomorphism for graphs.

Authors: Jakob Greilhuber, Dániel Marx, George Osipov, Marta Piecyk, Paweł Rzążewski, Stanislav Živný

We consider valued constraint satisfaction problems (VCSPs) with a fixed finite domain $D$ and a fixed finite constraint language $Γ$, in the setting where $Γ$ contains all crisp unary constraints (called hard lists) and the remaining cost functions are finite-valued. We call such a language a finite-valued hard-list language. Let $c_Γ$ be the size of the largest set $S\subseteq D$ such that $Γ$ can express (using the usual VCSP closure operations) a binary disequality function on elements of $S$. Our main result tightly connects the complexity of the problem parameterized by treewidth to this value $c_Γ$. (1) The problem can be solved in time $(c_Γ)^{\mathsf{tw}} \cdot (|I| + |\mathcal{T}|)^{O(1)}$ when given an instance $I$ with a tree decomposition $\mathcal{T}$ of width $\mathsf{tw}$ of the primal graph of $I$. (2) If $c_Γ\geq 2$, there is no such algorithm solving the problem in time $(c_Γ- \varepsilon)^{\mathsf{tw}} \cdot (|I| + |\mathcal{T}|)^{O(1)}$ for any $\varepsilon > 0$, unless the Primal Treewidth SETH (and hence CNF-SETH) fails. In particular, this gives a far-reaching generalization of a similar result of Esmer et al. [ESA 2024] on the optimization version of list homomorphism for graphs.

Individually Fair Facility Location

from arXiv: Data Structures and Algorithms

Authors: Rajni Dabas, Samir Khuller, Milind Maiti

We study individually fair facility location, where each client must connect to an open facility within a prescribed radius and the objective is to minimize total opening and connection cost. We show that preserving the radii changes the approximability of metric facility location fundamentally. For every fixed radius violation below three, no deterministic polynomial-time algorithm achieves a sublogarithmic cost factor unless $\mathrm{P}=\mathrm{NP}$. The hardness holds with uniform opening costs and uniform radii. It contradicts the strict-fairness constant-factor guarantee recently claimed by Liu, Xu, and Zhang [Theory of Computing Systems, Vol. 70 (2026)]. We then establish a positive result for arbitrary client radii. We give a randomized polynomial-time algorithm that has cost at most $1.725$ times the strictly fair optimum and serves every client within three times its fair radius (in the Appendix we show how this can be de-randomized). We use the approach of Byrka, Srinivasan and Swamy [IPCO 2010]. The facility-location radius factor three is therefore optimal among deterministic polynomial-time algorithms with constant cost factor, unless $\mathrm{P}=\mathrm{NP}$. Experiments on real-world data indicate that the worst case radius bound is rarely realized in practice: the algorithm serves over 99.8% of clients within their stated radius, and never beyond 1.5 times it. Our code is available at github.com/milindmaiti/IFFL_Implementation.

Authors: Rajni Dabas, Samir Khuller, Milind Maiti

We study individually fair facility location, where each client must connect to an open facility within a prescribed radius and the objective is to minimize total opening and connection cost. We show that preserving the radii changes the approximability of metric facility location fundamentally. For every fixed radius violation below three, no deterministic polynomial-time algorithm achieves a sublogarithmic cost factor unless $\mathrm{P}=\mathrm{NP}$. The hardness holds with uniform opening costs and uniform radii. It contradicts the strict-fairness constant-factor guarantee recently claimed by Liu, Xu, and Zhang [Theory of Computing Systems, Vol. 70 (2026)]. We then establish a positive result for arbitrary client radii. We give a randomized polynomial-time algorithm that has cost at most $1.725$ times the strictly fair optimum and serves every client within three times its fair radius (in the Appendix we show how this can be de-randomized). We use the approach of Byrka, Srinivasan and Swamy [IPCO 2010]. The facility-location radius factor three is therefore optimal among deterministic polynomial-time algorithms with constant cost factor, unless $\mathrm{P}=\mathrm{NP}$. Experiments on real-world data indicate that the worst case radius bound is rarely realized in practice: the algorithm serves over 99.8% of clients within their stated radius, and never beyond 1.5 times it. Our code is available at https://github.com/milindmaiti/IFFL_Implementation.

Sketching Language Models for Context Attribution

from arXiv: Data Structures and Algorithms

Authors: Christopher Liaw, Aranyak Mehta, Grigoris Velegkas, Felix Zhou

Context attribution asks how removing parts of a prompt changes a language model's output. We study leave-one-out (LOO) attribution for a prompt of $n$ tokens and a fixed measurement function. Computing all LOO values directly requires $n$ model evaluations. Under a stability assumption, our algorithm estimates all LOO values to error proportional to $\varepsilon$ with constant probability using $O(\sqrt{\log(1/\varepsilon)}/\varepsilon)$ evaluation calls. To complement our upper bound, we prove a matching $Ω(\sqrt{\log(1/\varepsilon)}/\varepsilon)$ lower bound on the number of evaluation calls in an oracle model. Empirically, we verify coefficient decay consistent with stability and evaluate the performance of our sketching algorithm on a small language-model retrieval task. Technically, our result is based on a sketching algorithm for arithmetic circuits whose Taylor coefficients satisfy the stability condition recently introduced by Gunn [Gun26]. A direct adaptation of their forward differentiation sketches would require $\widetilde{O}(\log(n)/\varepsilon^2)$ evaluation calls. Our key observation is that we can apply forward differentiation to the backpropagation circuit, with only constant overhead over a forward sketch of the same Taylor degree. This reduces the variance of the sketches and is key to our improved evaluation bound. Our lower bound builds on the techniques of Amsel, Chen, Duman Keles, Halikias, Musco, and Musco [ACDH+26, SIAM Journal on Matrix Analysis and Applications] for lower bounding the number of matrix-vector queries to estimate the diagonal elements of random matrices.

Authors: Christopher Liaw, Aranyak Mehta, Grigoris Velegkas, Felix Zhou

Context attribution asks how removing parts of a prompt changes a language model's output. We study leave-one-out (LOO) attribution for a prompt of $n$ tokens and a fixed measurement function. Computing all LOO values directly requires $n$ model evaluations. Under a stability assumption, our algorithm estimates all LOO values to error proportional to $\varepsilon$ with constant probability using $O(\sqrt{\log(1/\varepsilon)}/\varepsilon)$ evaluation calls. To complement our upper bound, we prove a matching $Ω(\sqrt{\log(1/\varepsilon)}/\varepsilon)$ lower bound on the number of evaluation calls in an oracle model. Empirically, we verify coefficient decay consistent with stability and evaluate the performance of our sketching algorithm on a small language-model retrieval task. Technically, our result is based on a sketching algorithm for arithmetic circuits whose Taylor coefficients satisfy the stability condition recently introduced by Gunn [Gun26]. A direct adaptation of their forward differentiation sketches would require $\widetilde{O}(\log(n)/\varepsilon^2)$ evaluation calls. Our key observation is that we can apply forward differentiation to the backpropagation circuit, with only constant overhead over a forward sketch of the same Taylor degree. This reduces the variance of the sketches and is key to our improved evaluation bound. Our lower bound builds on the techniques of Amsel, Chen, Duman Keles, Halikias, Musco, and Musco [ACDH+26, SIAM Journal on Matrix Analysis and Applications] for lower bounding the number of matrix-vector queries to estimate the diagonal elements of random matrices.

Integer Programming with Polyhedral Constraints on the Image

from arXiv: Data Structures and Algorithms

Authors: Anubhav Dhar, Tim Randolph, Karol Węgrzycki

We generalize integer programming to the setting in which the image $A \mathbf{x}$ is restricted to an explicitly given rational polyhedron $P$. That is, we solve $\min\{\mathbf{c}^{\mathsf T}\mathbf{x}:A\mathbf{x}\in P, \mathbf{x}\in\mathbb{Z}_{\geq 0}^n\}$, where $A\in\mathbb{Z}^{d\times n}$ and $P$ is an explicitly given rational polyhedron. We present a randomized algorithm running in time $(dΔ)^{O(d)}\operatorname{poly}(L)$ in this regime, where $Δ:= \|A\|_\infty$ and $L$ is the binary input length. This running time matches that of the best-known parameterized algorithms for integer programming, due to Eisenbrand and Weismantel and to Jansen and Rohwedder, and improves on the $O(d^2)$ exponent achieved by Dadush, Léonard, Rohwedder, and Verschae in a more general setting. This result enables several applications, including exact algorithms for integer programming and unbounded knapsack in which the consumed resources $A\mathbf{x}$ must satisfy arbitrary additional linear constraints. We also obtain a randomized fixed-parameter algorithm for Unbounded Subset Sum parameterized by the doubling constant, resolving an open problem of Randolph and Węgrzycki. For integer programs with $m$ constraints and bounded row doubling, we obtain an $f(C,m)n^{O(m)}\operatorname{poly}(L)$-time algorithm and show that the dependence on $m$ in the exponent of $n$ is necessary under $\mathsf{W[1]}\ne\mathsf{FPT}$.

Authors: Anubhav Dhar, Tim Randolph, Karol Węgrzycki

We generalize integer programming to the setting in which the image $A \mathbf{x}$ is restricted to an explicitly given rational polyhedron $P$. That is, we solve $\min\{\mathbf{c}^{\mathsf T}\mathbf{x}:A\mathbf{x}\in P, \mathbf{x}\in\mathbb{Z}_{\geq 0}^n\}$, where $A\in\mathbb{Z}^{d\times n}$ and $P$ is an explicitly given rational polyhedron. We present a randomized algorithm running in time $(dΔ)^{O(d)}\operatorname{poly}(L)$ in this regime, where $Δ:= \|A\|_\infty$ and $L$ is the binary input length. This running time matches that of the best-known parameterized algorithms for integer programming, due to Eisenbrand and Weismantel and to Jansen and Rohwedder, and improves on the $O(d^2)$ exponent achieved by Dadush, Léonard, Rohwedder, and Verschae in a more general setting. This result enables several applications, including exact algorithms for integer programming and unbounded knapsack in which the consumed resources $A\mathbf{x}$ must satisfy arbitrary additional linear constraints. We also obtain a randomized fixed-parameter algorithm for Unbounded Subset Sum parameterized by the doubling constant, resolving an open problem of Randolph and Węgrzycki. For integer programs with $m$ constraints and bounded row doubling, we obtain an $f(C,m)n^{O(m)}\operatorname{poly}(L)$-time algorithm and show that the dependence on $m$ in the exponent of $n$ is necessary under $\mathsf{W[1]}\ne\mathsf{FPT}$.

Separations Between Submodular-Like Graph Widths

from arXiv: Data Structures and Algorithms

Authors: Karl Bringmann, Egor Gorbachev

Many algorithmic frameworks exist for evaluating join queries. They range from simple ones, such as dynamic programming over a single tree decomposition, high-degree-low-degree splitting from graph algorithms, and the degree uniformization of Joglekar and Ré, to sophisticated ones based on information-theoretic inequalities, such as the PANDA framework for submodular width. Each of these frameworks except high-degree-low-degree splitting comes with a width notion of the query that determines its running-time exponent. We fill this gap by formalizing high-degree-low-degree splitting with $\ell$ degree classes, which gives rise to the degree-splitting width $\mathrm{ds}_\ell$-width. These width notions form a hierarchy, but it was not known whether the more complicated frameworks achieve better worst-case exponents than the simpler ones on any graph query. We study this question for full self-join-free join queries with binary relations, which amounts to colored subgraph isomorphism for a pattern graph $H$. We show that every inequality in the hierarchy $\mathrm{subw} \le \#\mathrm{subw} \le \text{m-width} \le \mathrm{ds}_\ell\text{-width}$ can be strict. For instance, $\text{m-width}(K_{3,3}) = 2 < \mathrm{ds}_\ell\text{-width}(K_{3,3})$ for every constant $\ell$, so no constant number of degree classes reaches the exponent of degree uniformization. We find the smallest separating patterns, with 8, 9, and 6 nodes, respectively, by an exhaustive search with a software tool that computes these widths via mixed integer linear programming. Along the way, we give a degree-based algorithm that removes the polylogarithmic overhead of degree uniformization when evaluating full join queries. Furthermore, we show that with logarithmically many degree classes, the degree-splitting width coincides with the m-width of Joglekar and Ré. Finally, we discuss several open problems.

Authors: Karl Bringmann, Egor Gorbachev

Many algorithmic frameworks exist for evaluating join queries. They range from simple ones, such as dynamic programming over a single tree decomposition, high-degree-low-degree splitting from graph algorithms, and the degree uniformization of Joglekar and Ré, to sophisticated ones based on information-theoretic inequalities, such as the PANDA framework for submodular width. Each of these frameworks except high-degree-low-degree splitting comes with a width notion of the query that determines its running-time exponent. We fill this gap by formalizing high-degree-low-degree splitting with $\ell$ degree classes, which gives rise to the degree-splitting width $\mathrm{ds}_\ell$-width. These width notions form a hierarchy, but it was not known whether the more complicated frameworks achieve better worst-case exponents than the simpler ones on any graph query. We study this question for full self-join-free join queries with binary relations, which amounts to colored subgraph isomorphism for a pattern graph $H$. We show that every inequality in the hierarchy $\mathrm{subw} \le \#\mathrm{subw} \le \text{m-width} \le \mathrm{ds}_\ell\text{-width}$ can be strict. For instance, $\text{m-width}(K_{3,3}) = 2 < \mathrm{ds}_\ell\text{-width}(K_{3,3})$ for every constant $\ell$, so no constant number of degree classes reaches the exponent of degree uniformization. We find the smallest separating patterns, with 8, 9, and 6 nodes, respectively, by an exhaustive search with a software tool that computes these widths via mixed integer linear programming. Along the way, we give a degree-based algorithm that removes the polylogarithmic overhead of degree uniformization when evaluating full join queries. Furthermore, we show that with logarithmically many degree classes, the degree-splitting width coincides with the m-width of Joglekar and Ré. Finally, we discuss several open problems.

Dynamic $k$-Median with Worst-Case Update Time and Recourse

from arXiv: Data Structures and Algorithms

Authors: Chenglin Fan

We study fully dynamic metric $k$-median under unit-weight client insertions and deletions. After each update, the algorithm must maintain at most $k$ centers chosen from the current client locations. We give a randomized constant-factor approximation algorithm with $\widetilde O(k)$ worst-case update time and $O((1+\logΔ)^3)$ worst-case center recourse, where $Δ$ is the aspect ratio of the underlying metric space. The approximation guarantee holds simultaneously over any prescribed finite adaptive update sequence with high probability, while the update time and recourse bounds hold on every execution. We also obtain the same asymptotic guarantees for metric $k$-means.

Authors: Chenglin Fan

We study fully dynamic metric $k$-median under unit-weight client insertions and deletions. After each update, the algorithm must maintain at most $k$ centers chosen from the current client locations. We give a randomized constant-factor approximation algorithm with $\widetilde O(k)$ worst-case update time and $O((1+\logΔ)^3)$ worst-case center recourse, where $Δ$ is the aspect ratio of the underlying metric space. The approximation guarantee holds simultaneously over any prescribed finite adaptive update sequence with high probability, while the update time and recourse bounds hold on every execution. We also obtain the same asymptotic guarantees for metric $k$-means.

The Submodular Secretary Problem: Tight $1-1/e$ for Monotone Objectives, and Strictly Between $1/e$ and $1/2$ in General

from arXiv: Data Structures and Algorithms

Authors: Hamed Abdi, Kiarash Banihashem, MohammadTaghi Hajiaghayi, Danny Mittal

In the submodular secretary problem with a cardinality constraint, $n$ elements arrive in uniformly random order, and an algorithm must irrevocably accept or reject each one on arrival so as to maximize a nonnegative submodular function over sets of at most $k$ elements. For monotone objectives we settle the problem: the optimal competitive ratio tends to exactly $1-1/e$ as $k\to\infty$, and its worst case over all budgets $k$ is exactly $1/e$. The bound $1-1/e$ cannot be exceeded even with unlimited computation, and it is achieved by a single algorithm with at most $4n+1$ value queries; previously the best ratio without a shortlist was $1/e-o(1)$, with exponentially many queries. For general objectives, where the best known ratio was about $0.107$, we show that the optimal limiting ratio lies strictly between $1/e$ and $1/2$: we achieve $1/e+3.5\cdot10^{-6}$ for large $k$, and no algorithm achieves more than $0.497053$. We also achieve $0.2677$ at every budget. The main new ingredient of our algorithm is eligibility attenuation: an element that passes the price test at time $t$ is accepted with probability $e^{-τ}$, where $τ$ is the total earlier time during which it would have passed, which makes the probability that it has already been selected exactly $1-e^{-τ}$.

Authors: Hamed Abdi, Kiarash Banihashem, MohammadTaghi Hajiaghayi, Danny Mittal

In the submodular secretary problem with a cardinality constraint, $n$ elements arrive in uniformly random order, and an algorithm must irrevocably accept or reject each one on arrival so as to maximize a nonnegative submodular function over sets of at most $k$ elements. For monotone objectives we settle the problem: the optimal competitive ratio tends to exactly $1-1/e$ as $k\to\infty$, and its worst case over all budgets $k$ is exactly $1/e$. The bound $1-1/e$ cannot be exceeded even with unlimited computation, and it is achieved by a single algorithm with at most $4n+1$ value queries; previously the best ratio without a shortlist was $1/e-o(1)$, with exponentially many queries. For general objectives, where the best known ratio was about $0.107$, we show that the optimal limiting ratio lies strictly between $1/e$ and $1/2$: we achieve $1/e+3.5\cdot10^{-6}$ for large $k$, and no algorithm achieves more than $0.497053$. We also achieve $0.2677$ at every budget. The main new ingredient of our algorithm is eligibility attenuation: an element that passes the price test at time $t$ is accepted with probability $e^{-τ}$, where $τ$ is the total earlier time during which it would have passed, which makes the probability that it has already been selected exactly $1-e^{-τ}$.

Matching in Random-Order Streams via Historical Deletion Bounds

from arXiv: Data Structures and Algorithms

Authors: Alireza Farhadi, Mohammadtaghi Hajiaghayi, Mohammad Mahdavi

We study maximum matching when the edges of a fixed graph arrive in a uniformly random order. For any fixed $\varepsilon>0$, we give a one-pass algorithm that achieves, with high probability over the arrival order, approximation ratios of $0.71295$ for unweighted graphs and $0.71295-\varepsilon$ for weighted graphs, using near-linear space with an explicit charge for weight precision. Both approximation ratios hold for bipartite and general graphs. The algorithm does not require the stream length or the weight range in advance. The main structural ingredient is a historical deletion inequality for weighted matchings. The deletion price of a vertex set is the decrease in maximum matching weight when that set is removed. We bound the sum of these prices for pairwise disjoint vertex sets, even when each price is evaluated at a different stage as edges are added to the graph. Applied to the usual unfolding of integer weights, it transfers a bipartite cardinality certificate to an original weighted matching, even when the original graph is not bipartite. This transfer preserves the approximation coefficient. We combine this transfer with a refined analysis of fractional matchings in the two auxiliary graphs arising in the transfer theorem. An exact rational linear-programming certificate proves the stated constant for every feasible graph profile. The approximation guarantees and the new structural results are formally verified in Lean.

Authors: Alireza Farhadi, Mohammadtaghi Hajiaghayi, Mohammad Mahdavi

We study maximum matching when the edges of a fixed graph arrive in a uniformly random order. For any fixed $\varepsilon>0$, we give a one-pass algorithm that achieves, with high probability over the arrival order, approximation ratios of $0.71295$ for unweighted graphs and $0.71295-\varepsilon$ for weighted graphs, using near-linear space with an explicit charge for weight precision. Both approximation ratios hold for bipartite and general graphs. The algorithm does not require the stream length or the weight range in advance. The main structural ingredient is a historical deletion inequality for weighted matchings. The deletion price of a vertex set is the decrease in maximum matching weight when that set is removed. We bound the sum of these prices for pairwise disjoint vertex sets, even when each price is evaluated at a different stage as edges are added to the graph. Applied to the usual unfolding of integer weights, it transfers a bipartite cardinality certificate to an original weighted matching, even when the original graph is not bipartite. This transfer preserves the approximation coefficient. We combine this transfer with a refined analysis of fractional matchings in the two auxiliary graphs arising in the transfer theorem. An exact rational linear-programming certificate proves the stated constant for every feasible graph profile. The approximation guarantees and the new structural results are formally verified in Lean.

Linear Regression with Self-Selection Bias in Polynomial Time

from arXiv: Data Structures and Algorithms

Authors: Felix Zhou

We revisit the problem of estimating $k$ linear regressors with self-selection bias in $n$ dimensions up to error $\varepsilon$ with the maximum self-selection criterion, as introduced by Cherapanamjeri, Daskalakis, Ilyas, and Zampetakis [CDIZ23, STOC]. Our main result is a $\mathrm{poly}(n,k,1/\varepsilon)$ time algorithm for the unknown-index variant of this problem, thereby improving upon the running times of the best known algorithms due to Gaitonde and Mossel [GM24] and Kalavasis, Mehrotra, and Zhou [KMZ26, COLT] with exponential dependence on $k$. Our algorithm succeeds in the presence of correlated noise between regressors, which captures the related setting of max-affine regression. Consequently, we also give the first polynomial-time algorithm for this problem, improving on the prior works of Ghosh, Pananjady, Guntuboyina, and Ramchandran [GPGR22, IEEE Transactions on Information Theory] and Gaitonde and Mossel [GM24] with exponential dependence on $k$. Prior works exhaustively search over a $k$-dimensional subspace spanned by the regressors, using conditional moments of the response to test candidates. In contrast, our algorithm is driven by an improved understanding of the moments of the covariates. We show that, restricting to observations with large response values, the degree-$(\log n)$ Hermite moment of the covariates approximately decomposes as a sum of tensor powers of the regressors. The first step of our algorithm can be viewed as a tensor decomposition algorithm for these implicitly represented high-order tensors, which outputs unit vectors parallel to the regressors. A secondary step based on a simple variant of ordinary least squares extracts estimates for the regressors given these unit vectors. We believe our analytic insight and algorithmic components may have applications to designing efficient algorithms for other latent-variable problems.

Authors: Felix Zhou

We revisit the problem of estimating $k$ linear regressors with self-selection bias in $n$ dimensions up to error $\varepsilon$ with the maximum self-selection criterion, as introduced by Cherapanamjeri, Daskalakis, Ilyas, and Zampetakis [CDIZ23, STOC]. Our main result is a $\mathrm{poly}(n,k,1/\varepsilon)$ time algorithm for the unknown-index variant of this problem, thereby improving upon the running times of the best known algorithms due to Gaitonde and Mossel [GM24] and Kalavasis, Mehrotra, and Zhou [KMZ26, COLT] with exponential dependence on $k$. Our algorithm succeeds in the presence of correlated noise between regressors, which captures the related setting of max-affine regression. Consequently, we also give the first polynomial-time algorithm for this problem, improving on the prior works of Ghosh, Pananjady, Guntuboyina, and Ramchandran [GPGR22, IEEE Transactions on Information Theory] and Gaitonde and Mossel [GM24] with exponential dependence on $k$. Prior works exhaustively search over a $k$-dimensional subspace spanned by the regressors, using conditional moments of the response to test candidates. In contrast, our algorithm is driven by an improved understanding of the moments of the covariates. We show that, restricting to observations with large response values, the degree-$(\log n)$ Hermite moment of the covariates approximately decomposes as a sum of tensor powers of the regressors. The first step of our algorithm can be viewed as a tensor decomposition algorithm for these implicitly represented high-order tensors, which outputs unit vectors parallel to the regressors. A secondary step based on a simple variant of ordinary least squares extracts estimates for the regressors given these unit vectors. We believe our analytic insight and algorithmic components may have applications to designing efficient algorithms for other latent-variable problems.

Combinatorial Bernoulli Factories with Polynomially Many Coins

from arXiv: Data Structures and Algorithms

Authors: Renato Paes Leme, Rad Niazadeh

We provide an efficient implementation of combinatorial Bernoulli factories. Such a factory turns coins of unknown biases $x$ into a random vertex of a polytope $P$ whose mean is exactly $x$. For every affine slice of the cube (the class of polytopes that admit a factory), we give a single algorithm whose expected number of coin flips and running time at every interior $x$ are polynomial in the dimension and in $1/{δ_*}$, where ${δ_*}=\min_i\{x_i,1-x_i\}$ is never supplied to the algorithm. For perfect matchings this gives $O(n^{8}{δ_*}^{-2}\log(n/{δ_*}))$ flips, while the factory of Niazadeh, Paes Leme, and Schneider [STOC 2021] spends at least $n^{2n-1}$ flips in expectation at the uniform doubly stochastic matrix. For other polytopes, our method rounds exactly given a point deep inside $P$ and the promise that $x$ is far from the boundary of $P$.

Authors: Renato Paes Leme, Rad Niazadeh

We provide an efficient implementation of combinatorial Bernoulli factories. Such a factory turns coins of unknown biases $x$ into a random vertex of a polytope $P$ whose mean is exactly $x$. For every affine slice of the cube (the class of polytopes that admit a factory), we give a single algorithm whose expected number of coin flips and running time at every interior $x$ are polynomial in the dimension and in $1/{δ_*}$, where ${δ_*}=\min_i\{x_i,1-x_i\}$ is never supplied to the algorithm. For perfect matchings this gives $O(n^{8}{δ_*}^{-2}\log(n/{δ_*}))$ flips, while the factory of Niazadeh, Paes Leme, and Schneider [STOC 2021] spends at least $n^{2n-1}$ flips in expectation at the uniform doubly stochastic matrix. For other polytopes, our method rounds exactly given a point deep inside $P$ and the promise that $x$ is far from the boundary of $P$.

A Little Length Slack Goes a Long Way in Planar Length-Constrained Network Design

from arXiv: Data Structures and Algorithms

Authors: D Ellis Hershkowitz, Richard Z Huang, Rhea Jain, Manas Korimilli

Problems in length-constrained network design ask for min-cost subgraphs connecting $k$ input vertex pairs by paths of length at most $h$. Algorithms that instead connect these pairs by paths of length at most $βh$ are said to have length slack $β$. Recent work has shown that poly-time polylogarithmic approximations with polylogarithmic length slack are possible for a broad class of both directed and multicommodity length-constrained network design problems on planar graphs. We give the first poly-time polylogarithmic approximations with $O(1)$ length slack for these problems on planar graphs. In particular, for the length-constrained setting, we give LP-competitive algorithms for planar graphs with length slack $1+ε$ and approximation ratios of $O(\log^2 k/ε)$ for directed Steiner tree and $O(\log^5 k/ε^2)$ for (undirected) Steiner forest. Similarly, for length-constrained directed Steiner forest, we give an $O(\log^6 k/ε)$ approximation on planar graphs with length slack $6+ε$. Our approach is based on a novel charging argument that charges the cost of our solution to the length of the LP and the length of our solution to the cost of the LP. We complement these algorithms with hardness results that separate planar and general graphs for both forest problems: under standard complexity assumptions, we rule out polylogarithmic approximations on general graphs with length slack below $3$.

Authors: D Ellis Hershkowitz, Richard Z Huang, Rhea Jain, Manas Korimilli

Problems in length-constrained network design ask for min-cost subgraphs connecting $k$ input vertex pairs by paths of length at most $h$. Algorithms that instead connect these pairs by paths of length at most $βh$ are said to have length slack $β$. Recent work has shown that poly-time polylogarithmic approximations with polylogarithmic length slack are possible for a broad class of both directed and multicommodity length-constrained network design problems on planar graphs. We give the first poly-time polylogarithmic approximations with $O(1)$ length slack for these problems on planar graphs. In particular, for the length-constrained setting, we give LP-competitive algorithms for planar graphs with length slack $1+ε$ and approximation ratios of $O(\log^2 k/ε)$ for directed Steiner tree and $O(\log^5 k/ε^2)$ for (undirected) Steiner forest. Similarly, for length-constrained directed Steiner forest, we give an $O(\log^6 k/ε)$ approximation on planar graphs with length slack $6+ε$. Our approach is based on a novel charging argument that charges the cost of our solution to the length of the LP and the length of our solution to the cost of the LP. We complement these algorithms with hardness results that separate planar and general graphs for both forest problems: under standard complexity assumptions, we rule out polylogarithmic approximations on general graphs with length slack below $3$.

Near-Optimal Regret for Oracle-Efficient Adversarial Contextual Bandits

from arXiv: Data Structures and Algorithms

Authors: Kiarash Banihashem, MohammadTaghi Hajiaghayi

We study contextual bandits with $K$ actions, a class of $N$ policies, and i.i.d.\ contexts from a distribution that the learner can sample. For any sequence of loss functions fixed before play, we give an oracle-efficient algorithm with expected regret $O(\sqrt{KT\log(2N)}\,\log(2KT))$ against the best policy in hindsight on the realized contexts. This improves the $T^{2/3}$ dependence on the horizon in prior oracle-efficient bounds and achieves the optimal regret rate in this setting up to logarithmic factors. Our algorithm perturbs policy scores using a Poisson sample of auxiliary contexts. At each sampled context, the perturbation assigned to an action is a Laplace noise draw multiplied by a scale specific to that context and action. We show that choosing these scales to minimize a convex objective determined by past observations yields the stated regret bound. We further approximate the minimizing scales by projected stochastic gradient descent using only an exact offline cost-sensitive optimization oracle that returns the optimum value. Since the table of scales can be large, the algorithm represents the SGD iterates implicitly by storing the random draws that determine each update and evaluates the scales only at queried contexts. Both the oracle complexity and the remaining resource bounds are polynomial in $T$, $K$, and $\log(2N)$.

Authors: Kiarash Banihashem, MohammadTaghi Hajiaghayi

We study contextual bandits with $K$ actions, a class of $N$ policies, and i.i.d.\ contexts from a distribution that the learner can sample. For any sequence of loss functions fixed before play, we give an oracle-efficient algorithm with expected regret $O(\sqrt{KT\log(2N)}\,\log(2KT))$ against the best policy in hindsight on the realized contexts. This improves the $T^{2/3}$ dependence on the horizon in prior oracle-efficient bounds and achieves the optimal regret rate in this setting up to logarithmic factors. Our algorithm perturbs policy scores using a Poisson sample of auxiliary contexts. At each sampled context, the perturbation assigned to an action is a Laplace noise draw multiplied by a scale specific to that context and action. We show that choosing these scales to minimize a convex objective determined by past observations yields the stated regret bound. We further approximate the minimizing scales by projected stochastic gradient descent using only an exact offline cost-sensitive optimization oracle that returns the optimum value. Since the table of scales can be large, the algorithm represents the SGD iterates implicitly by storing the random draws that determine each update and evaluates the scales only at queried contexts. Both the oracle complexity and the remaining resource bounds are polynomial in $T$, $K$, and $\log(2N)$.

Nearly Optimal Dilation for Non-Uniform k-Center with Constant-Factor Budget Violation

from arXiv: Data Structures and Algorithms

Authors: Jannis Blauth, Siri Prüßner

In Non-Uniform $k$-Center, we are given a metric space $(V,d)$ and $L$ levels of balls with prescribed radii $r_1 \ge \ldots \ge r_L$ and nonnegative integer budgets $k_1,\ldots,k_L$. The goal is to place at most $k_\ell$ centers of each level $\ell \in [L]$ in $V$ and minimize the dilation $λ$ such that the corresponding balls of radii $λr_1,\dots,λr_L$ cover $V$. While this problem admits no subexponential approximation factor unless P=NP, the picture changes drastically when additional centers are allowed. An $(α,β)$-bicriteria approximation to Smooth Non-Uniform $k$-Center covers $V$ with dilation $βλ_{\text{opt}}$ such that, for each $\ell \in [L]$, the number of centers of the first $\ell$ levels is at most $α$ times their total budget. For every fixed $\varepsilon>0$, we give a randomized $(1+\varepsilon,8+\varepsilon)$-approximation and a deterministic $(O_{\varepsilon}(1),2+\varepsilon)$-approximation, both running in polynomial time. Even for classical $k$-Center, obtaining an $(O(1),2-δ)$-approximation is NP-hard for every fixed $δ\in (0,1]$. Thus, our second result almost settles the optimal dilation when a constant-factor violation of the budget is allowed, unless P=NP. We combine a new primal-dual enumeration procedure with a simple bucketing argument that yields a new trade-off between the two approximation factors. It remains open whether there is a polynomial-time $(1+\varepsilon,2+\varepsilon)$-bicriteria approximation, which would almost match the classical $2$-approximation for $k$-Center.

Authors: Jannis Blauth, Siri Prüßner

In Non-Uniform $k$-Center, we are given a metric space $(V,d)$ and $L$ levels of balls with prescribed radii $r_1 \ge \ldots \ge r_L$ and nonnegative integer budgets $k_1,\ldots,k_L$. The goal is to place at most $k_\ell$ centers of each level $\ell \in [L]$ in $V$ and minimize the dilation $λ$ such that the corresponding balls of radii $λr_1,\dots,λr_L$ cover $V$. While this problem admits no subexponential approximation factor unless P=NP, the picture changes drastically when additional centers are allowed. An $(α,β)$-bicriteria approximation to Smooth Non-Uniform $k$-Center covers $V$ with dilation $βλ_{\text{opt}}$ such that, for each $\ell \in [L]$, the number of centers of the first $\ell$ levels is at most $α$ times their total budget. For every fixed $\varepsilon>0$, we give a randomized $(1+\varepsilon,8+\varepsilon)$-approximation and a deterministic $(O_{\varepsilon}(1),2+\varepsilon)$-approximation, both running in polynomial time. Even for classical $k$-Center, obtaining an $(O(1),2-δ)$-approximation is NP-hard for every fixed $δ\in (0,1]$. Thus, our second result almost settles the optimal dilation when a constant-factor violation of the budget is allowed, unless P=NP. We combine a new primal-dual enumeration procedure with a simple bucketing argument that yields a new trade-off between the two approximation factors. It remains open whether there is a polynomial-time $(1+\varepsilon,2+\varepsilon)$-bicriteria approximation, which would almost match the classical $2$-approximation for $k$-Center.

Online Transportation via Shifted Geometric Scales

from arXiv: Data Structures and Algorithms

Authors: John Jeang

In the Online Transportation problem, introduced by Kalyanasundaram and Pruhs (1995), requests arrive sequentially in a metric space and must be assigned immediately and irrevocably to one of $m$ facilities with available capacity. The objective is to minimize the total distance between requests and their assigned facilities. The problem generalizes the Online Metric Matching problem, in which each facility has unit capacity, and inherits a $2m-1$ lower bound on the competitive ratio for all deterministic algorithms. For Online Metric Matching, Kalyanasundaram and Pruhs (1993) and Khuller, Mitchell, and Vazirani (1994) established an optimal deterministic competitive ratio of $2m-1$, attained by the Retrospective (Permutation) algorithm. Kalyanasundaram and Pruhs (1998) conjectured that the same ratio is achievable for online transportation. Recently, Seth, Das, and Raghvendra (2026) obtained a competitive ratio of approximately $6.66m-2.89$ using their Robustified Greedy algorithm. We give an algorithm with competitive ratio $ρ(m-1)+1$, where $ρ\approx5.64$. Our algorithm builds on minimum-spanning-tree search techniques developed by Harada and Itoh (2025) and Arndt, Moseley, Pruhs, and Uetz (2026), using priority-based virtual depth-first searches over the known facilities. However our algorithm uses a phase to shift the geometric search scales, to decide when to skip certain searches and optimize the thresholds that define what edges to include in a given search.

Authors: John Jeang

In the Online Transportation problem, introduced by Kalyanasundaram and Pruhs (1995), requests arrive sequentially in a metric space and must be assigned immediately and irrevocably to one of $m$ facilities with available capacity. The objective is to minimize the total distance between requests and their assigned facilities. The problem generalizes the Online Metric Matching problem, in which each facility has unit capacity, and inherits a $2m-1$ lower bound on the competitive ratio for all deterministic algorithms. For Online Metric Matching, Kalyanasundaram and Pruhs (1993) and Khuller, Mitchell, and Vazirani (1994) established an optimal deterministic competitive ratio of $2m-1$, attained by the Retrospective (Permutation) algorithm. Kalyanasundaram and Pruhs (1998) conjectured that the same ratio is achievable for online transportation. Recently, Seth, Das, and Raghvendra (2026) obtained a competitive ratio of approximately $6.66m-2.89$ using their Robustified Greedy algorithm. We give an algorithm with competitive ratio $ρ(m-1)+1$, where $ρ\approx5.64$. Our algorithm builds on minimum-spanning-tree search techniques developed by Harada and Itoh (2025) and Arndt, Moseley, Pruhs, and Uetz (2026), using priority-based virtual depth-first searches over the known facilities. However our algorithm uses a phase to shift the geometric search scales, to decide when to skip certain searches and optimize the thresholds that define what edges to include in a given search.

List Update with Time Windows and Delays without Batch-Serving

from arXiv: Data Structures and Algorithms

Authors: Icey Siyi Ai, Jingwei Li, Clifford Stein

We study list update with time windows and delays when every request requires a separate access. Unlike batch-serving models, serving several requests to one element still incurs one access per request, and each access may change the list for subsequent requests. For time windows of overlap at most $k\ge2$, our deterministic First-Element Removal algorithm is $(3-2/k)$-competitive, hence $3$-competitive in general. Against an oblivious adversary, a randomized adaptation of BIT is $7/4$-competitive on arbitrary $2$-overlap inputs. More generally, on inputs without self-overlap, it is $\left(13/4-9/[2(k+1)]\right)$-competitive for every $k\ge2$. For delays, we give a deterministic $5$-competitive algorithm and a lower bound of $2+\sqrt3$ for deterministic delay-unaware algorithms. Our analyses extend inversion potentials with per-request credits that reconcile different service times and orders.

Authors: Icey Siyi Ai, Jingwei Li, Clifford Stein

We study list update with time windows and delays when every request requires a separate access. Unlike batch-serving models, serving several requests to one element still incurs one access per request, and each access may change the list for subsequent requests. For time windows of overlap at most $k\ge2$, our deterministic First-Element Removal algorithm is $(3-2/k)$-competitive, hence $3$-competitive in general. Against an oblivious adversary, a randomized adaptation of BIT is $7/4$-competitive on arbitrary $2$-overlap inputs. More generally, on inputs without self-overlap, it is $\left(13/4-9/[2(k+1)]\right)$-competitive for every $k\ge2$. For delays, we give a deterministic $5$-competitive algorithm and a lower bound of $2+\sqrt3$ for deterministic delay-unaware algorithms. Our analyses extend inversion potentials with per-request credits that reconcile different service times and orders.

A PTAS for Constraint Satisfaction Problems on Interval Graphs and Bounded Rank-Width Graphs

from arXiv: Data Structures and Algorithms

Authors: Ian DeHaan, Euiwoong Lee

We present a polynomial-time approximation scheme (PTAS) for all Boolean arity-two maximum constraint satisfaction problems (Boolean Max-2-CSP) where the constraint graph is either interval or has bounded rank-width. This class of problems includes, for example, Max-Cut, Max-DiCut, Max-2-Lin(2), and Max-2-SAT. In particular, this settles the approximability of Max-Cut on interval graphs. To achieve these results, we show the following. 1. For any $\varepsilon > 0$, there is an $n^{\mathcal O(r \varepsilon^{-2})}$-time $(1 - \varepsilon$)-approximation for Boolean Max-2-CSP on graphs of rank-width at most $r$. 2. There is a polynomial-time algorithm that, for any interval graph $G = (V, E)$ and $\varepsilon > 0$, finds a subgraph $H = (V, F)$ of $G$ such that $|F| \geq (1 - \varepsilon) |E|$ and $H$ has rank-width at most $\operatorname{poly}(\varepsilon^{-1})$. Our techniques additionally extend to all bounded-alphabet arity-two max CSPs.

Authors: Ian DeHaan, Euiwoong Lee

We present a polynomial-time approximation scheme (PTAS) for all Boolean arity-two maximum constraint satisfaction problems (Boolean Max-2-CSP) where the constraint graph is either interval or has bounded rank-width. This class of problems includes, for example, Max-Cut, Max-DiCut, Max-2-Lin(2), and Max-2-SAT. In particular, this settles the approximability of Max-Cut on interval graphs. To achieve these results, we show the following. 1. For any $\varepsilon > 0$, there is an $n^{\mathcal O(r \varepsilon^{-2})}$-time $(1 - \varepsilon$)-approximation for Boolean Max-2-CSP on graphs of rank-width at most $r$. 2. There is a polynomial-time algorithm that, for any interval graph $G = (V, E)$ and $\varepsilon > 0$, finds a subgraph $H = (V, F)$ of $G$ such that $|F| \geq (1 - \varepsilon) |E|$ and $H$ has rank-width at most $\operatorname{poly}(\varepsilon^{-1})$. Our techniques additionally extend to all bounded-alphabet arity-two max CSPs.

Edge-wise Graph Alignments

from arXiv: Data Structures and Algorithms

Authors: Akbar Davoodi, Christoph Flamm, Daniel Merkle, Peter F. Stadler

Pairwise graph ``alignments'', usually defined as maximum common subgraphs, have been considered in many application domains, including the comparison of molecular structures. Most commonly, the problem is formulated as maximum common induced subgraph (MCIS) or maximum common edge subgraph (MCES) problems. Sometimes these formulations are restricted to connected common subgraphs. Common subgraph problems readily generalize to more than two input graphs. However, this concept is fundamentally distinct from the notion of multiple sequence alignments. Abstractly, alignments are defined as super-structures from which the individual input objects are recovered via structure-preserving projections. While the mathematical construction readily applies to common induced subgraphs, it does not fully encompass the common edge subgraph problem, which is the variant more commonly employed in cheminformatics applications. In order to consistently define multiple edge-based alignments of graphs we represent a graph $G$ as E-graph $(E,\mathscr{V})$, where $E$ is the edge set of $G$ and $\mathscr{V}$ is the set of sets of incident edges. This representation implicitly encodes the vertices in terms of edge data. Alignments of E-graphs are themselves E-graphs that contain the input (E-)graphs as subgraphs. Maximum edge subgraphs correspond to maximum induced sub-E-graphs, and they can thus be computed using a slightly modified version of the VF2 algorithm without the need to switch from graphs to line graphs. Furthermore, multiple alignments of (E-)graphs yield a natural definition of a consensus graph that is ``on average'' present in the input without having to be a subgraph of every (and in fact of any) input graph.

Authors: Akbar Davoodi, Christoph Flamm, Daniel Merkle, Peter F. Stadler

Pairwise graph ``alignments'', usually defined as maximum common subgraphs, have been considered in many application domains, including the comparison of molecular structures. Most commonly, the problem is formulated as maximum common induced subgraph (MCIS) or maximum common edge subgraph (MCES) problems. Sometimes these formulations are restricted to connected common subgraphs. Common subgraph problems readily generalize to more than two input graphs. However, this concept is fundamentally distinct from the notion of multiple sequence alignments. Abstractly, alignments are defined as super-structures from which the individual input objects are recovered via structure-preserving projections. While the mathematical construction readily applies to common induced subgraphs, it does not fully encompass the common edge subgraph problem, which is the variant more commonly employed in cheminformatics applications. In order to consistently define multiple edge-based alignments of graphs we represent a graph $G$ as E-graph $(E,\mathscr{V})$, where $E$ is the edge set of $G$ and $\mathscr{V}$ is the set of sets of incident edges. This representation implicitly encodes the vertices in terms of edge data. Alignments of E-graphs are themselves E-graphs that contain the input (E-)graphs as subgraphs. Maximum edge subgraphs correspond to maximum induced sub-E-graphs, and they can thus be computed using a slightly modified version of the VF2 algorithm without the need to switch from graphs to line graphs. Furthermore, multiple alignments of (E-)graphs yield a natural definition of a consensus graph that is ``on average'' present in the input without having to be a subgraph of every (and in fact of any) input graph.

Tight Bounds for Downward-Closed Prophet and Secretary Problems

from arXiv: Data Structures and Algorithms

Authors: Hanrui Zhang

We study online selection problems subject to arbitrary downward-closed feasibility constraints, under different arrival orders, with different distributional assumptions. We establish the following bounds: (1) $Θ(\log^2 n / \log \log n)$ for the standard (adversarial-order) prophet problem, (2) $Ω(\log n)$ for the (Bayesian, random-order) prophet secretary problem, and by extension, for the standard (prior-free, random-order) secretary problem, and (3) $O(\log n / \log \log n)$ for the free-order prophet problem. Together with complementary bounds established in prior work, these results pin down the asymptotically tight competitive ratios for all these variants of prophet and secretary problems subject to downward-closed constraints. Our results refine and reinforce the big-decisions-first principle by Rubinstein and Singla [2026], establishing a superconstant separation between the random-order and free-order models.

Authors: Hanrui Zhang

We study online selection problems subject to arbitrary downward-closed feasibility constraints, under different arrival orders, with different distributional assumptions. We establish the following bounds: (1) $Θ(\log^2 n / \log \log n)$ for the standard (adversarial-order) prophet problem, (2) $Ω(\log n)$ for the (Bayesian, random-order) prophet secretary problem, and by extension, for the standard (prior-free, random-order) secretary problem, and (3) $O(\log n / \log \log n)$ for the free-order prophet problem. Together with complementary bounds established in prior work, these results pin down the asymptotically tight competitive ratios for all these variants of prophet and secretary problems subject to downward-closed constraints. Our results refine and reinforce the big-decisions-first principle by Rubinstein and Singla [2026], establishing a superconstant separation between the random-order and free-order models.

Locality Meets Interference: Structure and Scheduling in Radio Multicasting

from arXiv: Data Structures and Algorithms

Authors: Qin Xin

We study multipoint-to-multipoint multicasting in synchronous radio networks with unknown participant locations and unrestricted message aggregation. Let $n$ be the network size, $k$ the number of participants, and $d$ their hop diameter. A supplied distance-two coloring with $C$ colors yields completion within $(C-1)d+1$ slots and at most $nk$ transmissions. In unit disk graphs, coordinates, one-hop neighbor data, and a common degree bound $Δ_0$ suffice for a $15(Δ_0+1)$-color schedule. A known fixed separation bound permits optimal deterministic $Θ(d)$ completion from coordinates alone. Without geometric data, strong selectivity gives $O(d\min\{n,(Δ_0+1)^2\log n\})$ slots when $n$ is known. Independent random transmission gives $O((Δ_0+1)(d+\log(k/η)))$ slots with failure probability at most $η$; for fixed $Δ_0$, this simplifies to $O(d+\log(1/η))$. A star construction shows that the logarithmic term is necessary for this random rule when the degree grows. We extend color schedules to fixed deletions and subgraphs connected over bounded windows of cycles. Separate conditional reductions preserve additive costs under diameter guessing and control parameter-table and cluster preprocessing. Finally, a counterexample shows that pruning and reranking a breadth-first tree can destroy interference-free delivery. For one-hop designated delivery with receiver degree at most $b$, we prove that the optimal schedule length equals the chromatic number of an associated conflict graph and is at most $2b-1$, with matching examples.

Authors: Qin Xin

We study multipoint-to-multipoint multicasting in synchronous radio networks with unknown participant locations and unrestricted message aggregation. Let $n$ be the network size, $k$ the number of participants, and $d$ their hop diameter. A supplied distance-two coloring with $C$ colors yields completion within $(C-1)d+1$ slots and at most $nk$ transmissions. In unit disk graphs, coordinates, one-hop neighbor data, and a common degree bound $Δ_0$ suffice for a $15(Δ_0+1)$-color schedule. A known fixed separation bound permits optimal deterministic $Θ(d)$ completion from coordinates alone. Without geometric data, strong selectivity gives $O(d\min\{n,(Δ_0+1)^2\log n\})$ slots when $n$ is known. Independent random transmission gives $O((Δ_0+1)(d+\log(k/η)))$ slots with failure probability at most $η$; for fixed $Δ_0$, this simplifies to $O(d+\log(1/η))$. A star construction shows that the logarithmic term is necessary for this random rule when the degree grows. We extend color schedules to fixed deletions and subgraphs connected over bounded windows of cycles. Separate conditional reductions preserve additive costs under diameter guessing and control parameter-table and cluster preprocessing. Finally, a counterexample shows that pruning and reranking a breadth-first tree can destroy interference-free delivery. For one-hop designated delivery with receiver degree at most $b$, we prove that the optimal schedule length equals the chromatic number of an associated conflict graph and is at most $2b-1$, with matching examples.

Explicit Edit Codes via Multicoloring

from arXiv: Data Structures and Algorithms

Authors: Huiling Xie, Zitan Chen

For any fixed integers $q\ge2$ and $t\ge1$, we construct explicit $q$-ary codes of length $n$ that correct any combination of at most $t$ insertions, deletions, and substitutions, with redundancy at most $2t\log_q n+O_{q,t}(\log\log n)$ $q$-ary symbols. This matches the leading redundancy term of Levenshtein's classical existential bound. Building on the standard graph-coloring approach, we use a prime-based multicoloring of the edit-confusion graph to assign multiple colors to each $q$-ary word of length $m

Authors: Huiling Xie, Zitan Chen

For any fixed integers $q\ge2$ and $t\ge1$, we construct explicit $q$-ary codes of length $n$ that correct any combination of at most $t$ insertions, deletions, and substitutions, with redundancy at most $2t\log_q n+O_{q,t}(\log\log n)$ $q$-ary symbols. This matches the leading redundancy term of Levenshtein's classical existential bound. Building on the standard graph-coloring approach, we use a prime-based multicoloring of the edit-confusion graph to assign multiple colors to each $q$-ary word of length $m

Canonical Truncation for Mixed-Integer and Combinatorial n-Fold Optimization

from arXiv: Data Structures and Algorithms

Authors: Klaus Jansen, Felix Ohnesorge, Björn Schumacher

We consider a special block-structured integer program with $n$ blocks. Every block has a prescribed number of vectors that need to be selected while minimizing the objective $c^{\intercal}x + g(Ax)$, where $c$ is a rational cost vector, $A$ is an integral matrix with $d$ rows, and $g \colon \mathbb{Z}^d \to \mathbb{Q}\cup \{+\infty\}$ is an arbitrary function. We access $g$ via an oracle that minimizes $c^{\intercal}x + g(Ax)$ when all but $O(d)$ variables are fixed. Our algorithm runs in time $(ndΔ)^{O(d)}(Q + \text{poly}(|I|))$ where $Δ$ is the largest absolute value of an entry in $A$, $Q$ is the necessary time to evaluate the oracle for $g$ and $|I|$ is the size of the input. This model is a variation of the model studied by Dadush et al.~[IPCO 23]. Their model has only a single block but individual upper and lower bounds on the variables instead of prescribed block sums. For their model they present an algorithm with running time $t^d(dΔ)^{O(d^2)}Q$ where $t$ is the number of variables. We use our algorithm to solve mixed-integer linear programs with no upper bounds on the variables, a linear objective, and arbitrarily many constraints involving only fractional variables in time $(mΔ)^{O(m)}\text{poly}(|I|)$, where $m$ is the number of constraints involving integral variables and $Δ$ is the largest absolute value of coefficients of integral variables. This improves the dependence on $m$ in the exponent to asymptotically match the dependency in the integer setting. Further, we use our algorithm to generalize the parameterized algorithm for scheduling on uniformly related machines by Rohwedder~[ICALP 25] to obtain an algorithm for multiple knapsack with running time $w_{\max}^{O(d)}\text{poly}(|I|)$ where $w_{\max}$ is the maximum weight of an item and $d$ the number of different weights.

Authors: Klaus Jansen, Felix Ohnesorge, Björn Schumacher

We consider a special block-structured integer program with $n$ blocks. Every block has a prescribed number of vectors that need to be selected while minimizing the objective $c^{\intercal}x + g(Ax)$, where $c$ is a rational cost vector, $A$ is an integral matrix with $d$ rows, and $g \colon \mathbb{Z}^d \to \mathbb{Q}\cup \{+\infty\}$ is an arbitrary function. We access $g$ via an oracle that minimizes $c^{\intercal}x + g(Ax)$ when all but $O(d)$ variables are fixed. Our algorithm runs in time $(ndΔ)^{O(d)}(Q + \text{poly}(|I|))$ where $Δ$ is the largest absolute value of an entry in $A$, $Q$ is the necessary time to evaluate the oracle for $g$ and $|I|$ is the size of the input. This model is a variation of the model studied by Dadush et al.~[IPCO 23]. Their model has only a single block but individual upper and lower bounds on the variables instead of prescribed block sums. For their model they present an algorithm with running time $t^d(dΔ)^{O(d^2)}Q$ where $t$ is the number of variables. We use our algorithm to solve mixed-integer linear programs with no upper bounds on the variables, a linear objective, and arbitrarily many constraints involving only fractional variables in time $(mΔ)^{O(m)}\text{poly}(|I|)$, where $m$ is the number of constraints involving integral variables and $Δ$ is the largest absolute value of coefficients of integral variables. This improves the dependence on $m$ in the exponent to asymptotically match the dependency in the integer setting. Further, we use our algorithm to generalize the parameterized algorithm for scheduling on uniformly related machines by Rohwedder~[ICALP 25] to obtain an algorithm for multiple knapsack with running time $w_{\max}^{O(d)}\text{poly}(|I|)$ where $w_{\max}$ is the maximum weight of an item and $d$ the number of different weights.

Improved Deterministic Algorithms for $k$-SAT: Generalization of Chains and Recurrence Proof

from arXiv: Data Structures and Algorithms

Authors: Binbin Cui, S. Cliff Liu, Yongrui Yu

We present a deterministic algorithm for 3-SAT running in $1.32736^n$ time. The algorithm is built on a branching-and-chain framework augmented with a polynomial-time expansion procedure that joins short chains through additional clauses to form bounded-size blocks, which impose stronger constraints on the assignment space. After branching, the algorithm chooses between derandomized local search guided by the block structure and enumeration of block assignments together with selected port variables, reducing the remaining formula to 2-SAT. A weighted analysis of branching, partial-assignment, and local-search costs, together with inductive bounds for chains and block interactions, establishes the running-time guarantee. The framework is self-contained and also offers guidance for practical SAT solver design by identifying useful clause-overlap structures and suggesting when to switch between local-search and reduction-based strategies.

Authors: Binbin Cui, S. Cliff Liu, Yongrui Yu

We present a deterministic algorithm for 3-SAT running in $1.32736^n$ time. The algorithm is built on a branching-and-chain framework augmented with a polynomial-time expansion procedure that joins short chains through additional clauses to form bounded-size blocks, which impose stronger constraints on the assignment space. After branching, the algorithm chooses between derandomized local search guided by the block structure and enumeration of block assignments together with selected port variables, reducing the remaining formula to 2-SAT. A weighted analysis of branching, partial-assignment, and local-search costs, together with inductive bounds for chains and block interactions, establishes the running-time guarantee. The framework is self-contained and also offers guidance for practical SAT solver design by identifying useful clause-overlap structures and suggesting when to switch between local-search and reduction-based strategies.

A Polynomial-Time Sixth-Power Excluded Grid Theorem

from arXiv: Data Structures and Algorithms

Authors: Mohammad Hajiaghayi

We give a polynomial-time construction for a sixth-power excluded-grid theorem. Every graph whose treewidth is at least $g^6$ times a fixed polylogarithmic factor contains a $g\times g$ grid minor that our randomized algorithm finds with constant probability. The algorithm outputs an explicit minor model, and the exponent in its running time is independent of $g$. This improves the ninth-power existence bound of Chuzhoy and Tan~\cite{CT21} and the $g^{98}$ threshold in the polynomial-time construction of Chekuri and Chuzhoy~\cite{CC16}. Quantitative bounds relating treewidth to grid size are central to bidimensionality, developed by Demaine, Hajiaghayi, and collaborators~\cite{DH05,DH08}. The main ingredient is an asymmetric local routing theorem that uses substantially fewer attachment paths than backbone paths. A balanced recursion preserves connectivity by charging deletions to the boundary of a fixed reference cluster. We construct the smaller attachment sets through a routing hierarchy: either it exposes an accessible well-linked boundary, or its quotient graphs contain the desired grid. These arguments implement cluster splitting using approximate cuts and flow computations. An explicit cut-matching construction and a constructive grid-extraction procedure complete the algorithm. We also give a general packing--covering hypothesis for trees meeting three prescribed terminal sets under which the exponent can be reduced below six. A companion Lean development verifies the new construction, its success guarantee, and the composition of its polynomial running time, using explicit interfaces for the published algorithms and standard finite-data operations.

Authors: Mohammad Hajiaghayi

We give a polynomial-time construction for a sixth-power excluded-grid theorem. Every graph whose treewidth is at least $g^6$ times a fixed polylogarithmic factor contains a $g\times g$ grid minor that our randomized algorithm finds with constant probability. The algorithm outputs an explicit minor model, and the exponent in its running time is independent of $g$. This improves the ninth-power existence bound of Chuzhoy and Tan~\cite{CT21} and the $g^{98}$ threshold in the polynomial-time construction of Chekuri and Chuzhoy~\cite{CC16}. Quantitative bounds relating treewidth to grid size are central to bidimensionality, developed by Demaine, Hajiaghayi, and collaborators~\cite{DH05,DH08}. The main ingredient is an asymmetric local routing theorem that uses substantially fewer attachment paths than backbone paths. A balanced recursion preserves connectivity by charging deletions to the boundary of a fixed reference cluster. We construct the smaller attachment sets through a routing hierarchy: either it exposes an accessible well-linked boundary, or its quotient graphs contain the desired grid. These arguments implement cluster splitting using approximate cuts and flow computations. An explicit cut-matching construction and a constructive grid-extraction procedure complete the algorithm. We also give a general packing--covering hypothesis for trees meeting three prescribed terminal sets under which the exponent can be reduced below six. A companion Lean development verifies the new construction, its success guarantee, and the composition of its polynomial running time, using explicit interfaces for the published algorithms and standard finite-data operations.

Tight Cycle-Cover Inequalities and Improved Approximation for Shortest Common Superstring with Reverse Complements

from arXiv: Data Structures and Algorithms

Authors: Ryosuke Yamano, Tetsuo Shibuya

The Shortest Common Superstring (SCS) problem is a classical idealized model of genome assembly. However, SCS does not account for the double-stranded nature of DNA: sequencing reads may originate from either strand without a known orientation. This motivates a natural variant, Shortest Common Superstring with Reverse Complements (SCS-RC), which asks for a shortest string containing each input string or its reverse complement as a substring. For SCS, the MGREEDY algorithm constructs an optimal cycle cover of the overlap graph and concatenates the strings obtained by breaking each cycle at its minimum-overlap edge. This algorithm was recently shown to achieve a tight $3$-approximation. Its reverse-complement extension, MGREEDY-RC, also constructs an optimal cycle cover of the overlap graph augmented with reverse complements, but its best known approximation guarantee was $3.75$ (CPM 2026). We extend this cycle-cover inequality to SCS-RC and show that MGREEDY-RC achieves a $3$-approximation, which is tight even over the DNA alphabet. The $3$-approximation guarantee for MGREEDY-RC yields a $2.5$-approximation for TGREEDY-RC, which greedily merges the strings derived from the cycle cover. By replacing this greedy merging step with an algorithm based on a reduction to a maximum-weight Hamiltonian path problem constrained to contain a given perfect matching, we obtain a $(22/9+\varepsilon)$-approximation for every fixed $\varepsilon>0$. This improves upon the previous best ratio of $8/3$ (WABI 2026), establishing the best known polynomial-time approximation guarantee for SCS-RC.

Authors: Ryosuke Yamano, Tetsuo Shibuya

The Shortest Common Superstring (SCS) problem is a classical idealized model of genome assembly. However, SCS does not account for the double-stranded nature of DNA: sequencing reads may originate from either strand without a known orientation. This motivates a natural variant, Shortest Common Superstring with Reverse Complements (SCS-RC), which asks for a shortest string containing each input string or its reverse complement as a substring. For SCS, the MGREEDY algorithm constructs an optimal cycle cover of the overlap graph and concatenates the strings obtained by breaking each cycle at its minimum-overlap edge. This algorithm was recently shown to achieve a tight $3$-approximation. Its reverse-complement extension, MGREEDY-RC, also constructs an optimal cycle cover of the overlap graph augmented with reverse complements, but its best known approximation guarantee was $3.75$ (CPM 2026). We extend this cycle-cover inequality to SCS-RC and show that MGREEDY-RC achieves a $3$-approximation, which is tight even over the DNA alphabet. The $3$-approximation guarantee for MGREEDY-RC yields a $2.5$-approximation for TGREEDY-RC, which greedily merges the strings derived from the cycle cover. By replacing this greedy merging step with an algorithm based on a reduction to a maximum-weight Hamiltonian path problem constrained to contain a given perfect matching, we obtain a $(22/9+\varepsilon)$-approximation for every fixed $\varepsilon>0$. This improves upon the previous best ratio of $8/3$ (WABI 2026), establishing the best known polynomial-time approximation guarantee for SCS-RC.

Hardness, Approximation, and Parameterized Algorithms for Asynchronous Border Minimization

from arXiv: Data Structures and Algorithms

Authors: Giulian Buzatu, Adrian Miclăuş, Alexandru Popa

In the Asynchronous Border Minimization Problem (BMP), a set of DNA probe strings is placed on a grid and synthesized using a common sequence of nucleotide-deposition steps. At each step, every cell may accept or skip the offered nucleotide. The cost is the total number of disagreements between neighboring cells over all steps. We study both free placement, where the probes may be rearranged, and fixed placement, where their positions are given. We show that free-placement BMP on a square grid is NP-complete over three symbols. For one-dimensional BMP, we prove APX-hardness over a binary alphabet, and NP-completeness even when every probe has length two. We also obtain an $8/7$-approximation for the latter restriction. For square grids, we give a randomized $O(n^{1/4}\log n)$-approximation, improving the earlier $O(n^{1/4}\log^2 n)$ guarantee. Both free- and fixed-placement BMP on rectangular grids are fixed-parameter tractable when parameterized only by the allowed border cost.

Authors: Giulian Buzatu, Adrian Miclăuş, Alexandru Popa

In the Asynchronous Border Minimization Problem (BMP), a set of DNA probe strings is placed on a grid and synthesized using a common sequence of nucleotide-deposition steps. At each step, every cell may accept or skip the offered nucleotide. The cost is the total number of disagreements between neighboring cells over all steps. We study both free placement, where the probes may be rearranged, and fixed placement, where their positions are given. We show that free-placement BMP on a square grid is NP-complete over three symbols. For one-dimensional BMP, we prove APX-hardness over a binary alphabet, and NP-completeness even when every probe has length two. We also obtain an $8/7$-approximation for the latter restriction. For square grids, we give a randomized $O(n^{1/4}\log n)$-approximation, improving the earlier $O(n^{1/4}\log^2 n)$ guarantee. Both free- and fixed-placement BMP on rectangular grids are fixed-parameter tractable when parameterized only by the allowed border cost.

Online Survivable Network Design with Arbitrarily Small Connectivity Loss

from arXiv: Data Structures and Algorithms

Authors: MohammadTaghi Hajiaghayi, Saeed Seddighin

In the online survivable network design problem, a graph with edge costs is known in advance, and requests arrive one at a time. Each request is a pair of vertices $(s,t)$ with a connectivity requirement $k$, and the algorithm must irrevocably buy edges so that $s$ and $t$ are joined by $k$ edge-disjoint paths. The goal is to keep the total cost close to that of an optimal offline solution. Gupta, Krishnaswamy, and Ravi~\cite{GKR12} obtain an $O(k\log^3 n)$-competitive algorithm, where $k$ is the maximum requirement, without relaxing the connectivity requirement. Dehghani, Ehsani, Hajiaghayi, Liaghat, and Seddighin~\cite{DEHLS18} obtain a polylogarithmic competitive ratio when the connectivity requirement is allowed to be relaxed by a factor of $2+\varepsilon$. We show that relaxing the connectivity requirement by a factor of only $1+\varepsilon$ suffices to obtain a polylogarithmic competitive ratio.

Authors: MohammadTaghi Hajiaghayi, Saeed Seddighin

In the online survivable network design problem, a graph with edge costs is known in advance, and requests arrive one at a time. Each request is a pair of vertices $(s,t)$ with a connectivity requirement $k$, and the algorithm must irrevocably buy edges so that $s$ and $t$ are joined by $k$ edge-disjoint paths. The goal is to keep the total cost close to that of an optimal offline solution. Gupta, Krishnaswamy, and Ravi~\cite{GKR12} obtain an $O(k\log^3 n)$-competitive algorithm, where $k$ is the maximum requirement, without relaxing the connectivity requirement. Dehghani, Ehsani, Hajiaghayi, Liaghat, and Seddighin~\cite{DEHLS18} obtain a polylogarithmic competitive ratio when the connectivity requirement is allowed to be relaxed by a factor of $2+\varepsilon$. We show that relaxing the connectivity requirement by a factor of only $1+\varepsilon$ suffices to obtain a polylogarithmic competitive ratio.

When Elements Fail: Weighted Fault-Tolerant Matroid Bases

from arXiv: Data Structures and Algorithms

Authors: Madhumita Kundu, Soumi Nandi, Saket Saurabh

Given a rank-\(r\) matroid on \(n\) elements with nonnegative costs and a partition into safe and vulnerable elements, we seek a minimum-cost set that spans after every deletion of at most \(k\) selected vulnerable elements. We resolve several open questions posed by Bentert, Fomin, Golovach, and Morelle (ESA 2025) concerning weighted costs, nonuniform failures, and explicitly specified failure scenarios. To this end, we develop two compression methods. For matroids given by an independence oracle, weighted flat-avoidance representatives yield a bounded subset of the ground set containing an optimal solution and a \(2^{\mathcal{O}((r+k)^4)}n^{\mathcal{O}(1)}\)-time algorithm. This establishes fixed-parameter tractability for weighted costs and nonuniform failures simultaneously. For explicitly represented linear matroids, polynomial certificates allow us to compress families of partial solutions while preserving successful completions under all allowed failures. This yields a deterministic algorithm using \(2^{\mathcal{O}(kr(r+k)\log(r+1))}n^{\mathcal{O}(1)}\) field operations over arbitrary fields. Over fixed finite fields, a simpler reduction uses parallel classes. For explicitly listed failure scenarios, we obtain fixed-parameter algorithms parameterized by rank and the number of scenarios. In contrast, the size-budget decision version is W[1]-hard parameterized by rank and maximum scenario size, even on uniform matroids with two-element scenarios. \keywords{Matroids \and Fault tolerance \and Fixed-parameter algorithms \and Representative families}

Authors: Madhumita Kundu, Soumi Nandi, Saket Saurabh

Given a rank-\(r\) matroid on \(n\) elements with nonnegative costs and a partition into safe and vulnerable elements, we seek a minimum-cost set that spans after every deletion of at most \(k\) selected vulnerable elements. We resolve several open questions posed by Bentert, Fomin, Golovach, and Morelle (ESA 2025) concerning weighted costs, nonuniform failures, and explicitly specified failure scenarios. To this end, we develop two compression methods. For matroids given by an independence oracle, weighted flat-avoidance representatives yield a bounded subset of the ground set containing an optimal solution and a \(2^{\mathcal{O}((r+k)^4)}n^{\mathcal{O}(1)}\)-time algorithm. This establishes fixed-parameter tractability for weighted costs and nonuniform failures simultaneously. For explicitly represented linear matroids, polynomial certificates allow us to compress families of partial solutions while preserving successful completions under all allowed failures. This yields a deterministic algorithm using \(2^{\mathcal{O}(kr(r+k)\log(r+1))}n^{\mathcal{O}(1)}\) field operations over arbitrary fields. Over fixed finite fields, a simpler reduction uses parallel classes. For explicitly listed failure scenarios, we obtain fixed-parameter algorithms parameterized by rank and the number of scenarios. In contrast, the size-budget decision version is W[1]-hard parameterized by rank and maximum scenario size, even on uniform matroids with two-element scenarios. \keywords{Matroids \and Fault tolerance \and Fixed-parameter algorithms \and Representative families}

Optimal-Size Strong Connectivity Preservers under Two Edge Failures in Subcubic Time

from arXiv: Data Structures and Algorithms

Authors: Wanhee Lee, Chenglin Fan

A $k$-edge-failure strong connectivity preserver of a directed graph on $N$ vertices is a spanning subgraph that has the same strongly connected components as the input after each set of at most $k$ edge deletions. The lower-bound construction of Baswana, Choudhary, and Roditty [BCR18], adapted to strong connectivity in [CC20], gives the previous best bound of $Ω(2^kN)$ necessary edges. Hoppenworth, Saranurak, and Wang [HSW25] prove an $O(k4^kN\log N)$ upper bound, leaving a logarithmic gap for fixed $k$. We close this gap by giving an explicit strongly connected graph on $N=2^d$ vertices with $N-1+(N/2)\log_2N$ edges, every one of which is necessary in a two-failure preserver. Together with the upper bound of [HSW25], this proves that the optimal size in the worst case is $Θ_k(N\log N)$ for every fixed $k\geq2$, whereas it is $Θ(N)$ for $k=1$ [GIP20]. The same graph has a one-failure preserver with at most $3(N-1)$ edges. We also give a randomized algorithm that either returns a spanning subgraph or reports failure. For every fixed $c,\varepsilon>0$, with probability at least $1-N^{-c}$ it returns a correct preserver for $k=2$ with $O(N\log N)$ edges, in $\widetilde O(N^{(ω+3)/2+\varepsilon})$ time and $\widetilde O(N^2)$ space. Here $ω$ is the matrix multiplication exponent over a fixed finite field.

Authors: Wanhee Lee, Chenglin Fan

A $k$-edge-failure strong connectivity preserver of a directed graph on $N$ vertices is a spanning subgraph that has the same strongly connected components as the input after each set of at most $k$ edge deletions. The lower-bound construction of Baswana, Choudhary, and Roditty [BCR18], adapted to strong connectivity in [CC20], gives the previous best bound of $Ω(2^kN)$ necessary edges. Hoppenworth, Saranurak, and Wang [HSW25] prove an $O(k4^kN\log N)$ upper bound, leaving a logarithmic gap for fixed $k$. We close this gap by giving an explicit strongly connected graph on $N=2^d$ vertices with $N-1+(N/2)\log_2N$ edges, every one of which is necessary in a two-failure preserver. Together with the upper bound of [HSW25], this proves that the optimal size in the worst case is $Θ_k(N\log N)$ for every fixed $k\geq2$, whereas it is $Θ(N)$ for $k=1$ [GIP20]. The same graph has a one-failure preserver with at most $3(N-1)$ edges. We also give a randomized algorithm that either returns a spanning subgraph or reports failure. For every fixed $c,\varepsilon>0$, with probability at least $1-N^{-c}$ it returns a correct preserver for $k=2$ with $O(N\log N)$ edges, in $\widetilde O(N^{(ω+3)/2+\varepsilon})$ time and $\widetilde O(N^2)$ space. Here $ω$ is the matrix multiplication exponent over a fixed finite field.

A Binary Search Tree with the Unified Bound

from arXiv: Data Structures and Algorithms

Authors: Yang Cao, Haoran Qi, Hanzhi Wang

We give a deterministic online binary search tree (BST) that satisfies the unified bound of Iacono [SODA 2001], which subsumes the working-set and dynamic-finger bounds: it serves every sequence $X$ of $m$ searches on $n$ keys at total cost $O(m+\mathrm{UB}(X))$, and every single search at cost $O(\log n)$. Previously, no BST was known to satisfy the unified bound, even offline. As a consequence, the dynamic optimality conjecture implies Iacono's conjecture that splay trees satisfy the unified bound. We also show that the unified bound is $O((m+n)(1+\log c_σ))$ on every sequence of searches that avoids a fixed permutation $σ$, where $c_σ$ is the Füredi-Hajnal limit of $σ$. Hence every BST that satisfies the unified bound, including ours, serves such sequences at this cost. For permutations this bound is tight, and it improves the previous upper bound $O(nc_σ^2)$ on the optimal cost, due to Berendsohn, Kozma and Opler [STOC 2024]. Finally, we extend the tree to support insertions and deletions: a sequence $X$ of $m$ operations, starting from $n_0$ keys, costs $O(n_0+m+\mathrm{UB}(X))$ in total, where $\mathrm{UB}$ is now the extension of the unified bound to insertions and deletions by Bădoiu, Cole, Demaine and Iacono [TCS 2007]. Hence, if splay trees are dynamically optimal for searches, insertions and deletions, then they serve every such sequence at this total cost as well.

Authors: Yang Cao, Haoran Qi, Hanzhi Wang

We give a deterministic online binary search tree (BST) that satisfies the unified bound of Iacono [SODA 2001], which subsumes the working-set and dynamic-finger bounds: it serves every sequence $X$ of $m$ searches on $n$ keys at total cost $O(m+\mathrm{UB}(X))$, and every single search at cost $O(\log n)$. Previously, no BST was known to satisfy the unified bound, even offline. As a consequence, the dynamic optimality conjecture implies Iacono's conjecture that splay trees satisfy the unified bound. We also show that the unified bound is $O((m+n)(1+\log c_σ))$ on every sequence of searches that avoids a fixed permutation $σ$, where $c_σ$ is the Füredi-Hajnal limit of $σ$. Hence every BST that satisfies the unified bound, including ours, serves such sequences at this cost. For permutations this bound is tight, and it improves the previous upper bound $O(nc_σ^2)$ on the optimal cost, due to Berendsohn, Kozma and Opler [STOC 2024]. Finally, we extend the tree to support insertions and deletions: a sequence $X$ of $m$ operations, starting from $n_0$ keys, costs $O(n_0+m+\mathrm{UB}(X))$ in total, where $\mathrm{UB}$ is now the extension of the unified bound to insertions and deletions by Bădoiu, Cole, Demaine and Iacono [TCS 2007]. Hence, if splay trees are dynamically optimal for searches, insertions and deletions, then they serve every such sequence at this total cost as well.

A One-Sided Sublinear-Query Tester for Bounded-Degree 2SAT

from arXiv: Data Structures and Algorithms

Authors: Yuichi Yoshida

We give a one-sided tester for satisfiability of 2CNF formulas in the bounded-degree model. For every degree bound $Δ$, distance parameter $\varepsilon>0$, and $ν\in(0,1/2)$, its query complexity on $n$-variable formulas is $\widetilde O_{\varepsilon,Δ,ν}(n^{1/2+ν})$.

Authors: Yuichi Yoshida

We give a one-sided tester for satisfiability of 2CNF formulas in the bounded-degree model. For every degree bound $Δ$, distance parameter $\varepsilon>0$, and $ν\in(0,1/2)$, its query complexity on $n$-variable formulas is $\widetilde O_{\varepsilon,Δ,ν}(n^{1/2+ν})$.

Exact and Approximation Algorithms for Computing Smallest SESs and BMSs

from arXiv: Data Structures and Algorithms

Authors: Hiroki Shibata, Hideo Bannai

Compression schemes represent repetitive strings compactly by using repeated substrings. Computing the minimum size of a representation of a given input string is important for compression and for understanding relationships between compression schemes, although this task is NP-hard for several schemes. In this paper, we introduce exact and approximation algorithms for finding smallest substring equation systems (SESs) and bidirectional macro schemes (BMSs). Specifically, for an input string of length $n$, we give deterministic and randomized algorithms for computing a smallest SES using $O^*(4^n)$ and $O^*(2^n)$ time and space, respectively. We also give a deterministic algorithm for computing a smallest BMS using $O^*(2^n)$ time and space. We further give deterministic and randomized $(1+α)$-approximation algorithms for smallest SESs using $O^*(4^{e^{-α}n})$ and $O^*(2^{e^{-α}n})$ time and space, respectively, for every $α\ge 0$. A conversion from SESs to BMSs gives $4(1+α)$-approximation algorithms for smallest BMSs with the same time and space bounds. All time bounds hold in the worst case, and the randomized algorithms return correct answers with high probability. Our algorithms adapt several approaches to exact and approximation algorithms for combinatorial problems, such as dynamic programming over determinant expansions and a greedy algorithm for monotone submodular functions.

Authors: Hiroki Shibata, Hideo Bannai

Compression schemes represent repetitive strings compactly by using repeated substrings. Computing the minimum size of a representation of a given input string is important for compression and for understanding relationships between compression schemes, although this task is NP-hard for several schemes. In this paper, we introduce exact and approximation algorithms for finding smallest substring equation systems (SESs) and bidirectional macro schemes (BMSs). Specifically, for an input string of length $n$, we give deterministic and randomized algorithms for computing a smallest SES using $O^*(4^n)$ and $O^*(2^n)$ time and space, respectively. We also give a deterministic algorithm for computing a smallest BMS using $O^*(2^n)$ time and space. We further give deterministic and randomized $(1+α)$-approximation algorithms for smallest SESs using $O^*(4^{e^{-α}n})$ and $O^*(2^{e^{-α}n})$ time and space, respectively, for every $α\ge 0$. A conversion from SESs to BMSs gives $4(1+α)$-approximation algorithms for smallest BMSs with the same time and space bounds. All time bounds hold in the worst case, and the randomized algorithms return correct answers with high probability. Our algorithms adapt several approaches to exact and approximation algorithms for combinatorial problems, such as dynamic programming over determinant expansions and a greedy algorithm for monotone submodular functions.

An EPTAS for Max-Cut on Interval Graphs

from arXiv: Data Structures and Algorithms

Authors: Hani Ahmadzadeh, Morteza Alimi

Max-Cut was shown NP-hard on interval graphs by Adhikary, Bose, Mukherjee, and Roy (SoCG 2021). The best previously known approximation ratio for this class, due to Ahn, DeHaan, Kim, and Lee (APPROX 2025), exceeded the Goemans--Williamson ratio of about $0.878$ by only $10^{-34}$. We give a deterministic efficient polynomial-time approximation scheme (EPTAS): for every $\varepsilon\in(0,1)$, a $(1-\varepsilon)$-approximate cut of an unweighted $n$-vertex interval graph can be found in time $2^{O(\varepsilon^{-2}\log^3(2/\varepsilon))}n^2$. The same guarantee and running time hold for Max-Bisection. An FPTAS is impossible unless $\mathrm{P}=\mathrm{NP}$. Our algorithm rests on a structural theorem: every interval graph with $m$ edges can be turned into an interval graph of clique-width $O(\varepsilon^{-2}\log^2(2/\varepsilon))$ by deleting at most $\varepsilon m$ edges. The construction combines endpoint-rank coordinates, length-dependent rounding, and a shifted dyadic hierarchy. Intervals intersecting cell boundaries at their own scales are isolated at small total edge cost; the interactions of remaining long intervals with smaller subproblems can be summarized by counts. The structural theorem also yields a randomized EPTAS via Lampis's scheme for bounded clique-width; our direct dynamic program is deterministic and handles Max-Bisection. Finally, for every $\varepsilon>0$, it is NP-hard to approximate Max-Cut within $84/85+\varepsilon$ on unweighted chordal graphs, which contain interval graphs. Thus an approximation scheme for Max-Cut on chordal graphs would imply $\mathrm{P}=\mathrm{NP}$.

Authors: Hani Ahmadzadeh, Morteza Alimi

Max-Cut was shown NP-hard on interval graphs by Adhikary, Bose, Mukherjee, and Roy (SoCG 2021). The best previously known approximation ratio for this class, due to Ahn, DeHaan, Kim, and Lee (APPROX 2025), exceeded the Goemans--Williamson ratio of about $0.878$ by only $10^{-34}$. We give a deterministic efficient polynomial-time approximation scheme (EPTAS): for every $\varepsilon\in(0,1)$, a $(1-\varepsilon)$-approximate cut of an unweighted $n$-vertex interval graph can be found in time $2^{O(\varepsilon^{-2}\log^3(2/\varepsilon))}n^2$. The same guarantee and running time hold for Max-Bisection. An FPTAS is impossible unless $\mathrm{P}=\mathrm{NP}$. Our algorithm rests on a structural theorem: every interval graph with $m$ edges can be turned into an interval graph of clique-width $O(\varepsilon^{-2}\log^2(2/\varepsilon))$ by deleting at most $\varepsilon m$ edges. The construction combines endpoint-rank coordinates, length-dependent rounding, and a shifted dyadic hierarchy. Intervals intersecting cell boundaries at their own scales are isolated at small total edge cost; the interactions of remaining long intervals with smaller subproblems can be summarized by counts. The structural theorem also yields a randomized EPTAS via Lampis's scheme for bounded clique-width; our direct dynamic program is deterministic and handles Max-Bisection. Finally, for every $\varepsilon>0$, it is NP-hard to approximate Max-Cut within $84/85+\varepsilon$ on unweighted chordal graphs, which contain interval graphs. Thus an approximation scheme for Max-Cut on chordal graphs would imply $\mathrm{P}=\mathrm{NP}$.

Plurality Consensus for $h$-Majority via First-Repetition Rules

from arXiv: Data Structures and Algorithms

Authors: Niccolò D'Archivio, George Giakkoupis, Frédéric Giroire, Emanuele Natale

In the h-Majority dynamics, each of n agents holds one of k opinions and, in every synchronous round, observes the opinions of h agents chosen independently and uniformly at random and adopts a most frequent one among them, breaking ties uniformly at random. Let M_0 be the initial number of agents holding the most frequent opinion, and Delta_0 its bias, its lead over the second most frequent opinion. We show that, for every sample size h >= 3, if Delta_0 >= L sqrt(M_0 log n) max{1, n/(h^2 M_0)} for a sufficiently large constant L, then h-Majority reaches consensus on the initially most frequent opinion within O((1 + n/(h^2 M_0)) log n) rounds with high probability. This is the time bound proved for the DejaVu dynamics with h samples (arXiv:2604.03648); our bias condition is that of DejaVu when h >= sqrt(n/M_0), and larger by a factor sqrt(n/(h^2 M_0)) otherwise. Our main contribution, the analysis of one round, rests on a comparison principle: among all rules that read the same observations and treat opinions symmetrically, plurality maximizes the difference between the probability of outputting the most frequent opinion and that of outputting any fixed competitor. We apply it to the rule that adopts the first opinion repeated among h-1 observations, and otherwise the h-th observation: its output law is the law of the new opinion of a random agent after one round of DejaVu with h-1 samples. Hence, in expectation, one round of h-Majority widens the gap between the most frequent opinion and each competitor at least as much as that round of DejaVu, whose analysis we use as a black box. Independently and concurrently, d'Amore, Rybicki, Shimizu, Shiraga and Vacus (arXiv:2610.40562) obtained, among other results, the same time bound under the weaker bias condition of DejaVu, with a different analysis of one round and a martingale analysis over many rounds.

Authors: Niccolò D'Archivio, George Giakkoupis, Frédéric Giroire, Emanuele Natale

In the h-Majority dynamics, each of n agents holds one of k opinions and, in every synchronous round, observes the opinions of h agents chosen independently and uniformly at random and adopts a most frequent one among them, breaking ties uniformly at random. Let M_0 be the initial number of agents holding the most frequent opinion, and Delta_0 its bias, its lead over the second most frequent opinion. We show that, for every sample size h >= 3, if Delta_0 >= L sqrt(M_0 log n) max{1, n/(h^2 M_0)} for a sufficiently large constant L, then h-Majority reaches consensus on the initially most frequent opinion within O((1 + n/(h^2 M_0)) log n) rounds with high probability. This is the time bound proved for the DejaVu dynamics with h samples (arXiv:2604.03648); our bias condition is that of DejaVu when h >= sqrt(n/M_0), and larger by a factor sqrt(n/(h^2 M_0)) otherwise. Our main contribution, the analysis of one round, rests on a comparison principle: among all rules that read the same observations and treat opinions symmetrically, plurality maximizes the difference between the probability of outputting the most frequent opinion and that of outputting any fixed competitor. We apply it to the rule that adopts the first opinion repeated among h-1 observations, and otherwise the h-th observation: its output law is the law of the new opinion of a random agent after one round of DejaVu with h-1 samples. Hence, in expectation, one round of h-Majority widens the gap between the most frequent opinion and each competitor at least as much as that round of DejaVu, whose analysis we use as a black box. Independently and concurrently, d'Amore, Rybicki, Shimizu, Shiraga and Vacus (arXiv:2610.40562) obtained, among other results, the same time bound under the weaker bias condition of DejaVu, with a different analysis of one round and a martingale analysis over many rounds.

Efficient Influence Minimization via Source-Integrated Sampling

from arXiv: Data Structures and Algorithms

Authors: Jingbang Chen, Junyao Wang

Influence minimization by node blocking is a fundamental problem in graph data management that seeks a small set of vertices whose removal minimizes the expected spread from a fixed source set. It supports decisions about where to intervene in large interaction networks to control harmful propagation, such as the spread of rumors and infectious diseases. Under the Independent Cascade (IC) model, selecting blockers requires comparing a large number of candidate sets, and estimating their effects on propagation can be costly. We propose SIG (Source-Integrated Greedy), a sampling framework for efficiently finding high-quality approximate solutions. Our key idea is to group the possible sets of neighbors directly activated by the sources according to their effects on blocker selection. SIG represents these groups in a compact weighted tree and computes their probabilities directly, allowing each sample to account for all source outcomes without enumerating them. We prove that SIG produces unbiased estimates of the lower-bound objective without increasing variance for fixed blocking plans, and establish a high-probability quality guarantee through independent validation. Extensive experiments on real-world networks show that SIG has the lowest mean total running time in all main comparisons, with speedups of up to 583x over the fastest baseline. SIG produces solutions competitive with those of prior methods and achieves the highest influence reduction in multiple settings, including on many of the largest networks, where several baselines exceed the runtime limit. Additional experiments show that SIG maintains consistently low running times as graph size and the blocking budget increase, while delivering stronger blocking solutions at larger budgets.

Authors: Jingbang Chen, Junyao Wang

Influence minimization by node blocking is a fundamental problem in graph data management that seeks a small set of vertices whose removal minimizes the expected spread from a fixed source set. It supports decisions about where to intervene in large interaction networks to control harmful propagation, such as the spread of rumors and infectious diseases. Under the Independent Cascade (IC) model, selecting blockers requires comparing a large number of candidate sets, and estimating their effects on propagation can be costly. We propose SIG (Source-Integrated Greedy), a sampling framework for efficiently finding high-quality approximate solutions. Our key idea is to group the possible sets of neighbors directly activated by the sources according to their effects on blocker selection. SIG represents these groups in a compact weighted tree and computes their probabilities directly, allowing each sample to account for all source outcomes without enumerating them. We prove that SIG produces unbiased estimates of the lower-bound objective without increasing variance for fixed blocking plans, and establish a high-probability quality guarantee through independent validation. Extensive experiments on real-world networks show that SIG has the lowest mean total running time in all main comparisons, with speedups of up to 583x over the fastest baseline. SIG produces solutions competitive with those of prior methods and achieves the highest influence reduction in multiple settings, including on many of the largest networks, where several baselines exceed the runtime limit. Additional experiments show that SIG maintains consistently low running times as graph size and the blocking budget increase, while delivering stronger blocking solutions at larger budgets.

Thursday, November 12

Postdoc at Bocconi University (apply by January 15, 2027)

from CCI: jobs

A 2-year postdoc position in algorithms at Bocconi. About our theory group: cs.unibocconi.eu/research/theory About life in Milan: lucatrevisan.wordpress.com/category/places/bocconi/ Salary range: EUR45–60k gross per year (researchers moving from abroad can benefit from a very favorable fiscal regime). Website: jobmarket.unibocconi.eu/?id=1013 Email: adam.polak@unibocconi.it

A 2-year postdoc position in algorithms at Bocconi. About our theory group: https://cs.unibocconi.eu/research/theory About life in Milan: https://lucatrevisan.wordpress.com/category/places/bocconi/ Salary range: EUR45–60k gross per year (researchers moving from abroad can benefit from a very favorable fiscal regime).

Website: https://jobmarket.unibocconi.eu/?id=1013
Email: adam.polak@unibocconi.it

By shacharlovett

Theory and Algorithms: Tenure-Track Assistant Professor in Computer Science at University of New Mexico (apply by December 5, 2026)

from CCI: jobs

The Department of Computer Science in the School of Engineering at the University of New Mexico invites applications for a full-time, tenure-track Assistant Professor position. We welcome candidates in all areas of computing, particularly those with expertise in quantum computing, theory and algorithms, or cybersecurity. Website: cs.unm.edu/news/2026/10/assistant-professor-position.html Email: saia@unm.edu

The Department of Computer Science in the School of Engineering at the University of New Mexico invites applications for a full-time, tenure-track Assistant Professor position. We welcome candidates in all areas of computing, particularly those with expertise in quantum computing, theory and algorithms, or cybersecurity.

Website: https://cs.unm.edu/news/2026/10/assistant-professor-position.html
Email: saia@unm.edu

By shacharlovett

TENURE-TRACK / TENURED FACULTY AT INSAIT at INSAIT – Institute for Computer Science, Artificial Intelligence and Technology (apply by January 31, 2027)

from CCI: jobs

INSAIT invites applications for multiple faculty positions in Theoretical Computer Science, Algorithms, and Complexity. Modelled after top research institutes, INSAIT offers world-class facilities, competitive salaries, generous funding for hiring and travel, and full research autonomy. We welcome applicants of all ranks, including tenured faculty to co-lead and grow the new Theory group. Website: insait.ai/faculty/ Email: […]

INSAIT invites applications for multiple faculty positions in Theoretical Computer Science, Algorithms, and Complexity. Modelled after top research institutes, INSAIT offers world-class facilities, competitive salaries, generous funding for hiring and travel, and full research autonomy. We welcome applicants of all ranks, including tenured faculty to co-lead and grow the new Theory group.

Website: https://insait.ai/faculty/
Email: contact@insait.ai

By shacharlovett

POSTDOC AT INSAIT at INSAIT – Institute for Computer Science, Artificial Intelligence and Technology (apply by January 31, 2027)

from CCI: jobs

INSAIT invites applications for multiple postdoctoral positions in Theoretical Computer Science, Algorithms, and Complexity. Modelled after top research institutes, INSAIT offers world-class facilities, competitive salaries, and generous funding for research and travel. We welcome outstanding researchers eager to contribute to the research of the ERC Advanced Grant-funded Theory@INSAIT group. Website: insait.ai/post-doc-at-insait/ Email: contact@insait.ai

INSAIT invites applications for multiple postdoctoral positions in Theoretical Computer Science, Algorithms, and Complexity. Modelled after top research institutes, INSAIT offers world-class facilities, competitive salaries, and generous funding for research and travel. We welcome outstanding researchers eager to contribute to the research of the ERC Advanced Grant-funded Theory@INSAIT group.

Website: https://insait.ai/post-doc-at-insait/
Email: contact@insait.ai

By shacharlovett

Statistical-to-computational gaps in central limit theorems for high-dimensional tensors

from arXiv: Computational Complexity

Authors: Debsurya De, Dmitriy Kunisky

We study high-dimensional central limit theorems (CLTs) as hypothesis testing problems, comparing the number of summands needed for statistical and computational indistinguishability of the normalized sum from the limiting Gaussian distribution as the dimension and number of summands grow together. For the off-diagonal entries of sums of i.i.d. rank-one tensors formed from standard Gaussian vectors (equivalently, the problem of distinguishing Wigner from Wishart tensors), we prove total variation bounds sharpening previous estimates of Mikulincer (2020) and give matching polynomial-time tests. This shows that the statistical and computational thresholds coincide for this CLT, contrary to a proposal by Kunisky, Moore, and Wein (2024). On the other hand, we also show that, for tensors of order at least three, sufficient Gaussian dilution of the summands by adding independent Gaussian noise and rescaling gives a CLT model with a statistical-to-computational gap (in the above setting and ones with more general rank-one summand distributions). To the best of our knowledge, such a phenomenon has not been observed before in any high-dimensional CLT. In particular, in the relevant parameter regimes, we show that a brute-force search achieves strong detection, while polynomials of degree up to $n^{Ω(1)}$ cannot achieve strong separation. The latter lower bounds control low-degree $χ^2$-divergences by a novel method based on cumulant generating functions, and we further illustrate the use of these tools by applying them to masked tensor CLT models where only a prescribed subset of tensor entries is revealed.

Authors: Debsurya De, Dmitriy Kunisky

We study high-dimensional central limit theorems (CLTs) as hypothesis testing problems, comparing the number of summands needed for statistical and computational indistinguishability of the normalized sum from the limiting Gaussian distribution as the dimension and number of summands grow together. For the off-diagonal entries of sums of i.i.d. rank-one tensors formed from standard Gaussian vectors (equivalently, the problem of distinguishing Wigner from Wishart tensors), we prove total variation bounds sharpening previous estimates of Mikulincer (2020) and give matching polynomial-time tests. This shows that the statistical and computational thresholds coincide for this CLT, contrary to a proposal by Kunisky, Moore, and Wein (2024). On the other hand, we also show that, for tensors of order at least three, sufficient Gaussian dilution of the summands by adding independent Gaussian noise and rescaling gives a CLT model with a statistical-to-computational gap (in the above setting and ones with more general rank-one summand distributions). To the best of our knowledge, such a phenomenon has not been observed before in any high-dimensional CLT. In particular, in the relevant parameter regimes, we show that a brute-force search achieves strong detection, while polynomials of degree up to $n^{Ω(1)}$ cannot achieve strong separation. The latter lower bounds control low-degree $χ^2$-divergences by a novel method based on cumulant generating functions, and we further illustrate the use of these tools by applying them to masked tensor CLT models where only a prescribed subset of tensor entries is revealed.

A Linear-Time Construction on $\mathbb{S}^2$ Achieving a Sublinear Energy Gap on Smale's Seventh Problem

from arXiv: Computational Geometry

Authors: Rishabh Kabra, Wim Dehaen, Andrea Karlova, Mark Hamilton, Joao Carreira, Maks Ovsjanikov, Jonathan T. Barron

Smale's seventh problem asks for a polynomial-time algorithm that places $N$ points on the unit sphere $\mathbb{S}^2$ with logarithmic energy (the sum of $-\log$ of all pairwise distances) within $O(\log N)$ of the minimum. The minimal energy has an asymptotic expansion with explicit terms of order $N^2$ and $N\log N$ and a linear term whose constant is unknown. Brauchart, Hardin, and Saff conjectured this constant; the resulting expansion, $E_{BHS}(N)$, is known to be an upper bound on the minimum, up to $o(N)$. All previously analyzed constructions on $\mathbb{S}^2$ have energy exceeding $E_{BHS}(N)$ by an amount that grows at least linearly in $N$, i.e. $Ω(N)$, far from the $O(\log N)$ accuracy sought by Smale. We present TerracedZonal, a deterministic construction that generates $N$ points in $Θ(N)$ time and memory. Points are placed on latitude rings whose populations are held constant across bands ("terraces") chosen by a one-dimensional dynamic program, so that adjacent rings within each terrace lock into a staggered triangular lattice. Under a locality assumption, we prove that the energy exceeds $E_{BHS}(N)$ by only $Θ(N^{2/3})$, with an explicit constant; exact evaluation up to $N = 10^9$ confirms this rate. Under the same assumption, its distance from the true minimum is sublinear if the conjecture holds. To our knowledge, this is the first algorithmic construction with a sublinear excess over $E_{BHS}(N)$ of explicit order (proven under the locality assumption), a necessary step toward Smale's seventh problem. With one parameter changed, the same algorithm also gives an equal-weight integration rule on $\mathbb{S}^2$ that runs just as fast and whose error decays at an empirical rate of $N^{-4}$ on smooth functions, versus $N^{-3/2}$ for every previous fast construction we tested.

Authors: Rishabh Kabra, Wim Dehaen, Andrea Karlova, Mark Hamilton, Joao Carreira, Maks Ovsjanikov, Jonathan T. Barron

Smale's seventh problem asks for a polynomial-time algorithm that places $N$ points on the unit sphere $\mathbb{S}^2$ with logarithmic energy (the sum of $-\log$ of all pairwise distances) within $O(\log N)$ of the minimum. The minimal energy has an asymptotic expansion with explicit terms of order $N^2$ and $N\log N$ and a linear term whose constant is unknown. Brauchart, Hardin, and Saff conjectured this constant; the resulting expansion, $E_{BHS}(N)$, is known to be an upper bound on the minimum, up to $o(N)$. All previously analyzed constructions on $\mathbb{S}^2$ have energy exceeding $E_{BHS}(N)$ by an amount that grows at least linearly in $N$, i.e. $Ω(N)$, far from the $O(\log N)$ accuracy sought by Smale. We present TerracedZonal, a deterministic construction that generates $N$ points in $Θ(N)$ time and memory. Points are placed on latitude rings whose populations are held constant across bands ("terraces") chosen by a one-dimensional dynamic program, so that adjacent rings within each terrace lock into a staggered triangular lattice. Under a locality assumption, we prove that the energy exceeds $E_{BHS}(N)$ by only $Θ(N^{2/3})$, with an explicit constant; exact evaluation up to $N = 10^9$ confirms this rate. Under the same assumption, its distance from the true minimum is sublinear if the conjecture holds. To our knowledge, this is the first algorithmic construction with a sublinear excess over $E_{BHS}(N)$ of explicit order (proven under the locality assumption), a necessary step toward Smale's seventh problem. With one parameter changed, the same algorithm also gives an equal-weight integration rule on $\mathbb{S}^2$ that runs just as fast and whose error decays at an empirical rate of $N^{-4}$ on smooth functions, versus $N^{-3/2}$ for every previous fast construction we tested.

Delaunay-Based Nearest Neighbor Search with Grid-Accelerated Queries and Parallel Construction

from arXiv: Computational Geometry

Authors: Pengfei Wang, Shiqing Xin, Changhe Tu

Nearest-neighbor search is a fundamental primitive in computer graphics, with applications in distance field computation, surface reconstruction, and point cloud registration. In many graphics applications, data points lie on a surface manifold embedded in 3D space, whereas queries are distributed throughout the surrounding volume, a setting in which spatial partitioning structures such as k-d trees and grids can become inefficient. Dynamic-programming-based nearest-neighbor search (DP-NNS) offers an alternative: it traverses a successor DAG that records the history of incremental Delaunay construction and often outperforms spatial partitioning structures. However, its sequential construction is slow, and naive parallelization degrades query performance, limiting its practical adoption. We accelerate both queries and construction in DP-NNS. For queries, we introduce a grid-based initialization strategy that precomputes valid starting points on the successor DAG, shortening search paths while preserving exactness and enabling a twofold speedup. For construction, we analyze how parallel insertion affects query cost and develop a parallel algorithm that preserves logarithmic expected query cost under stated geometric assumptions. Our parallel construction algorithm achieves a 10x speedup over the sequential baseline while maintaining nearly the same query cost. We further reorder query points to improve cache locality. Extensive experiments demonstrate that our method outperforms widely used libraries in nearest-neighbor query performance.

Authors: Pengfei Wang, Shiqing Xin, Changhe Tu

Nearest-neighbor search is a fundamental primitive in computer graphics, with applications in distance field computation, surface reconstruction, and point cloud registration. In many graphics applications, data points lie on a surface manifold embedded in 3D space, whereas queries are distributed throughout the surrounding volume, a setting in which spatial partitioning structures such as k-d trees and grids can become inefficient. Dynamic-programming-based nearest-neighbor search (DP-NNS) offers an alternative: it traverses a successor DAG that records the history of incremental Delaunay construction and often outperforms spatial partitioning structures. However, its sequential construction is slow, and naive parallelization degrades query performance, limiting its practical adoption. We accelerate both queries and construction in DP-NNS. For queries, we introduce a grid-based initialization strategy that precomputes valid starting points on the successor DAG, shortening search paths while preserving exactness and enabling a twofold speedup. For construction, we analyze how parallel insertion affects query cost and develop a parallel algorithm that preserves logarithmic expected query cost under stated geometric assumptions. Our parallel construction algorithm achieves a 10x speedup over the sequential baseline while maintaining nearly the same query cost. We further reorder query points to improve cache locality. Extensive experiments demonstrate that our method outperforms widely used libraries in nearest-neighbor query performance.

Almost Optimal Lower Bounds under Almost ETH for Approximating Euclidean k-means

from arXiv: Data Structures and Algorithms

Authors: Karthik C. S., Dor Minzer

In the Euclidean $k$-means problem, we are given a set of $n$ points in $\mathbb{R}^d$, and the goal is to find $k$ representative points in space so as to minimize the sum of the squared distances from each point to its closest representative. Algorithmically, de la Vega, Karpinski, Kenyon, and Rabani [STOC'03] and Kumar, Sabharwal, and Sen [JACM'10] obtain a $(1+\varepsilon)$-approximation for high-dimensional Euclidean $k$-means in time $2^{(k/\varepsilon)^{O(1)}} \cdot dn^{O(1)}$, which was subsequently improved to $2^{\tilde{O}(k/\varepsilon)} + O(ndk)$ by Feldman, Monemizadeh, and Sohler [SoCG'07]. On the lower-bound side, a recent work of Cohen-Addad, Karthik, Saulpic, and Schwiegelshohn [SoCG'26] proposed the Exponential Time for Expanders Hypothesis (XXH), which asserts exponential-time hardness for $(1+\varepsilon)$-approximating Vertex Cover on vertex expanders, and used it to prove nearly matching running time lower bound whenever $k=\tildeω(1/\varepsilon)$. We observe that XXH does not hold in the parameter regime needed for the above result, and show how to repair their reduction under a more standard assumption. More precisely, we show that assuming the Almost Exponential Time Hypothesis for 3-SAT (Almost ETH), for every constant $β\in(0,1)$, Euclidean $k$-means in $\mathbb{R}^d$ has no $(1+\varepsilon)$-approximation algorithm running in time $2^{(k/\varepsilon)^{1-β}}\text{poly}(n,d)$, whenever $k=\tildeω(1/\varepsilon)$. By modifying the construction, we also obtain a similar result for approximating the Euclidean $k$-median problem.

Authors: Karthik C. S., Dor Minzer

In the Euclidean $k$-means problem, we are given a set of $n$ points in $\mathbb{R}^d$, and the goal is to find $k$ representative points in space so as to minimize the sum of the squared distances from each point to its closest representative. Algorithmically, de la Vega, Karpinski, Kenyon, and Rabani [STOC'03] and Kumar, Sabharwal, and Sen [JACM'10] obtain a $(1+\varepsilon)$-approximation for high-dimensional Euclidean $k$-means in time $2^{(k/\varepsilon)^{O(1)}} \cdot dn^{O(1)}$, which was subsequently improved to $2^{\tilde{O}(k/\varepsilon)} + O(ndk)$ by Feldman, Monemizadeh, and Sohler [SoCG'07]. On the lower-bound side, a recent work of Cohen-Addad, Karthik, Saulpic, and Schwiegelshohn [SoCG'26] proposed the Exponential Time for Expanders Hypothesis (XXH), which asserts exponential-time hardness for $(1+\varepsilon)$-approximating Vertex Cover on vertex expanders, and used it to prove nearly matching running time lower bound whenever $k=\tildeω(1/\varepsilon)$. We observe that XXH does not hold in the parameter regime needed for the above result, and show how to repair their reduction under a more standard assumption. More precisely, we show that assuming the Almost Exponential Time Hypothesis for 3-SAT (Almost ETH), for every constant $β\in(0,1)$, Euclidean $k$-means in $\mathbb{R}^d$ has no $(1+\varepsilon)$-approximation algorithm running in time $2^{(k/\varepsilon)^{1-β}}\text{poly}(n,d)$, whenever $k=\tildeω(1/\varepsilon)$. By modifying the construction, we also obtain a similar result for approximating the Euclidean $k$-median problem.

Two-Stage Mixed-Integer Quadratic Programming in Polynomial Time

from arXiv: Data Structures and Algorithms

Authors: Alberto Del Pia

Lenstra showed that mixed-integer linear programming can be solved in polynomial time when the number of integer variables is fixed and the number of continuous variables is arbitrary. Mixed-integer quadratic programming (MIQP) can be solved in polynomial time when the total number of variables is fixed. However, since MIQP is NP-hard already without integer variables, the analog of Lenstra's result fails unless P = NP. Hence, polynomial-time algorithms for MIQP with an arbitrary number of continuous variables must exploit additional structure. We study MIQPs with two-stage structure, which underlies Benders decomposition and two-stage stochastic programming. A few linking variables, including all integer variables, are coupled with many blocks of continuous variables that interact only through them, both in the constraints and in the objective. We give a polynomial-time algorithm for MIQP with an arbitrary quadratic objective when the number of linking variables and the block size are fixed, while the number of blocks, and hence the number of variables, is arbitrary. The case with no blocks is MIQP in fixed dimension. None of our assumptions can be dropped. Unless P = NP, the number of linking variables and the block size must both be fixed, the blocks cannot interact or contain integer variables, and large blocks cannot be allowed even if their objective is linear. Unless FPT = W[1], the exponent of the running time must depend on both the number of linking variables and the block size.

Authors: Alberto Del Pia

Lenstra showed that mixed-integer linear programming can be solved in polynomial time when the number of integer variables is fixed and the number of continuous variables is arbitrary. Mixed-integer quadratic programming (MIQP) can be solved in polynomial time when the total number of variables is fixed. However, since MIQP is NP-hard already without integer variables, the analog of Lenstra's result fails unless P = NP. Hence, polynomial-time algorithms for MIQP with an arbitrary number of continuous variables must exploit additional structure. We study MIQPs with two-stage structure, which underlies Benders decomposition and two-stage stochastic programming. A few linking variables, including all integer variables, are coupled with many blocks of continuous variables that interact only through them, both in the constraints and in the objective. We give a polynomial-time algorithm for MIQP with an arbitrary quadratic objective when the number of linking variables and the block size are fixed, while the number of blocks, and hence the number of variables, is arbitrary. The case with no blocks is MIQP in fixed dimension. None of our assumptions can be dropped. Unless P = NP, the number of linking variables and the block size must both be fixed, the blocks cannot interact or contain integer variables, and large blocks cannot be allowed even if their objective is linear. Unless FPT = W[1], the exponent of the running time must depend on both the number of linking variables and the block size.

$k$-Product Lists for (Generalized) Feedback Vertex Sets: A Tool for Designing FPT Algorithms

from arXiv: Data Structures and Algorithms

Authors: Rin Saito, Yuma Tamura

Enumerating all inclusion-minimal solutions is a powerful approach to designing fixed-parameter tractable (FPT) algorithms. However, for the \textsc{Feedback Vertex Set} problem, this approach faces a fundamental obstacle, as the number of minimal feedback vertex sets is not, in general, bounded by any function of the solution size~$k$. To overcome this limitation, we introduce a data structure called a \emph{$k$-product list}, which implicitly encodes all minimal solutions while admitting non-minimal ones to maintain efficiency. We present FPT algorithms for computing such lists not only for the \textsc{Feedback Vertex Set} problem but also for its natural generalizations, the \textsc{$\ell$-Forest Deletion Set} problem and the \textsc{$r$-Pseudoforest Deletion Set} problem. Our framework yields simple FPT algorithms for a wide range of variants, providing the first such results in several cases and demonstrating the broad applicability of our approach.

Authors: Rin Saito, Yuma Tamura

Enumerating all inclusion-minimal solutions is a powerful approach to designing fixed-parameter tractable (FPT) algorithms. However, for the \textsc{Feedback Vertex Set} problem, this approach faces a fundamental obstacle, as the number of minimal feedback vertex sets is not, in general, bounded by any function of the solution size~$k$. To overcome this limitation, we introduce a data structure called a \emph{$k$-product list}, which implicitly encodes all minimal solutions while admitting non-minimal ones to maintain efficiency. We present FPT algorithms for computing such lists not only for the \textsc{Feedback Vertex Set} problem but also for its natural generalizations, the \textsc{$\ell$-Forest Deletion Set} problem and the \textsc{$r$-Pseudoforest Deletion Set} problem. Our framework yields simple FPT algorithms for a wide range of variants, providing the first such results in several cases and demonstrating the broad applicability of our approach.

Characterizing Local Breadth in Language Generation

from arXiv: Data Structures and Algorithms

Authors: Jon Kleinberg, Fan Wei

Large language models sharpen the validity--breadth trade-off: a generator should avoid hallucinations without collapsing onto a narrow set of valid outputs. We study generation from positive examples of an unknown target in the Kleinberg--Mullainathan model, with arbitrary, possibly adversarial order and no distributional or computational assumptions. Breadth is measured by lower Banach density, which rules out arbitrarily large sparse holes, unlike prefix-based lower asymptotic density. 1. Exact optima in one dimension: For each target $K$ in a countable family, we characterize its optimal lower Banach density $b(K)$ via equivalent combinatorial and topological formulations. One eventually valid generator attains all $b(K)$ simultaneously. Every $α\in[0,1/2]$ occurs as $b(K)$ in some countable family; finite Cantor--Bendixson point rank guarantees $b(K)=1/2$, even without a uniform rank bound. 2. Unavoidable trade-offs in higher dimensions: For $d\ge2$, there need not be a single best generator: optimizing density for one target may worsen the guarantee for another. An explicit family quantifies this intrinsically multi-objective trade-off. 3. Complete characterization of density profiles: We characterize the full region of simultaneously achievable guarantees, with equivalent combinatorial and topological formulations, after excluding geometrically degenerate rectangles. Every prescribed product $\prod_i[0,α_i]$, $α_i\in[0,1/2]$ can occur as an exact achievable region for some language collection. 4. Near-half guarantees and the sharp endpoint: Under a near-logarithmic nondegeneracy condition, one generator achieves filtered density at least $1/2-\varepsilon$ at all finite-point-rank targets, for every $\varepsilon>0$, improving the previous polylogarithmic threshold. The exact $1/2$ endpoint can fail even for a rank-zero singleton family.

Authors: Jon Kleinberg, Fan Wei

Large language models sharpen the validity--breadth trade-off: a generator should avoid hallucinations without collapsing onto a narrow set of valid outputs. We study generation from positive examples of an unknown target in the Kleinberg--Mullainathan model, with arbitrary, possibly adversarial order and no distributional or computational assumptions. Breadth is measured by lower Banach density, which rules out arbitrarily large sparse holes, unlike prefix-based lower asymptotic density. 1. Exact optima in one dimension: For each target $K$ in a countable family, we characterize its optimal lower Banach density $b(K)$ via equivalent combinatorial and topological formulations. One eventually valid generator attains all $b(K)$ simultaneously. Every $α\in[0,1/2]$ occurs as $b(K)$ in some countable family; finite Cantor--Bendixson point rank guarantees $b(K)=1/2$, even without a uniform rank bound. 2. Unavoidable trade-offs in higher dimensions: For $d\ge2$, there need not be a single best generator: optimizing density for one target may worsen the guarantee for another. An explicit family quantifies this intrinsically multi-objective trade-off. 3. Complete characterization of density profiles: We characterize the full region of simultaneously achievable guarantees, with equivalent combinatorial and topological formulations, after excluding geometrically degenerate rectangles. Every prescribed product $\prod_i[0,α_i]$, $α_i\in[0,1/2]$ can occur as an exact achievable region for some language collection. 4. Near-half guarantees and the sharp endpoint: Under a near-logarithmic nondegeneracy condition, one generator achieves filtered density at least $1/2-\varepsilon$ at all finite-point-rank targets, for every $\varepsilon>0$, improving the previous polylogarithmic threshold. The exact $1/2$ endpoint can fail even for a rank-zero singleton family.

The Price of Anarchy in Markets for Lemons

from arXiv: Data Structures and Algorithms

Authors: Naveen Durvasula, Tim Roughgarden

We study the worst-case equilibrium gains from trade in simple bilateral trade mechanisms with interdependent valuations. Equilibria in such settings are typically complex, as proposed prices can convey private information held by the proposer. Such equilibria suffer lost gains from trade both due to the inefficiency introduced by screening (as in independent private value settings) and due to adverse selection. We identify broad conditions under which, nevertheless, sequential equilibria are guaranteed to achieve a constant fraction of the first-best gains from trade. Our bounds quantify the central role of rare pessimistic seller signals and rare optimistic buyer signals. The results apply to seller-proposer, buyer-proposer, and random-proposer mechanisms. The key idea in our analysis is to relate equilibrium gains from trade to proposer profits in an auxiliary market with independent private values.

Authors: Naveen Durvasula, Tim Roughgarden

We study the worst-case equilibrium gains from trade in simple bilateral trade mechanisms with interdependent valuations. Equilibria in such settings are typically complex, as proposed prices can convey private information held by the proposer. Such equilibria suffer lost gains from trade both due to the inefficiency introduced by screening (as in independent private value settings) and due to adverse selection. We identify broad conditions under which, nevertheless, sequential equilibria are guaranteed to achieve a constant fraction of the first-best gains from trade. Our bounds quantify the central role of rare pessimistic seller signals and rare optimistic buyer signals. The results apply to seller-proposer, buyer-proposer, and random-proposer mechanisms. The key idea in our analysis is to relate equilibrium gains from trade to proposer profits in an auxiliary market with independent private values.

Sublogarithmic Online Graph Exploration

from arXiv: Data Structures and Algorithms

Authors: Julia Baligacs

We study the online graph exploration problem, in which an agent must visit every vertex of an initially unknown weighted graph on $n$ vertices and return to its starting vertex. In this model, a vertex's incident edges and their weights are revealed when it is first visited. Despite extensive research, the best known competitive guarantee for general graphs had remained $\mathcal{O}(\log n)$, a bound already established in 1977 for the greedy TSP heuristic Nearest Neighbor. Subsequent approaches, including hierarchical depth-first search (hDFS) and Blocking, achieve better guarantees on restricted graph classes but have logarithmic or worse competitive ratios on general graphs. This raises the question of whether the logarithmic barrier is inherent and Nearest Neighbor is asymptotically optimal. We answer this question in the negative by giving an $\mathcal{O}(\log n/\log \log n)$-competitive algorithm. Our algorithm is a slight modification of hDFS, and we establish its competitive guarantee with a surprisingly short proof.

Authors: Julia Baligacs

We study the online graph exploration problem, in which an agent must visit every vertex of an initially unknown weighted graph on $n$ vertices and return to its starting vertex. In this model, a vertex's incident edges and their weights are revealed when it is first visited. Despite extensive research, the best known competitive guarantee for general graphs had remained $\mathcal{O}(\log n)$, a bound already established in 1977 for the greedy TSP heuristic Nearest Neighbor. Subsequent approaches, including hierarchical depth-first search (hDFS) and Blocking, achieve better guarantees on restricted graph classes but have logarithmic or worse competitive ratios on general graphs. This raises the question of whether the logarithmic barrier is inherent and Nearest Neighbor is asymptotically optimal. We answer this question in the negative by giving an $\mathcal{O}(\log n/\log \log n)$-competitive algorithm. Our algorithm is a slight modification of hDFS, and we establish its competitive guarantee with a surprisingly short proof.

Tripod Reordering: A 33-Queue Layout of Planar Graphs

from arXiv: Data Structures and Algorithms

Authors: Sergey Pupyrev

A queue layout of a graph consists of a linear order of the vertices and a partition of the edges into queues so that no two edges in a single queue are nested. The minimum number of queues needed in a queue layout of a graph is called its queue number. A planar product structure theorem of Dujmović, Joret, Micek, Morin, Ueckerdt, and Wood (JACM, 2020) states that every planar graph is a subgraph of the strong product of a graph of simple treewidth at most $3$, a clique $K_3$, and a path. The result has been used to show that the queue number of planar graphs is at most $49$. Recently, Bekos, Gronemann, and Raftopoulou (Algorithmica, 2023) investigated how the general approach based on the product structure can be optimized for planar graphs. They claim that an appropriate reordering of the three vertices associated with each bag in the product structure decomposition, called a tripod, reduces the queue number of planar graphs to $42$. We first highlight a gap in their queue layout algorithm: one of the choices required by the algorithm is not guaranteed to exist. Then we show how to address the limitation and provide an alternative tripod reordering mechanism that reduces the upper bound on the queue number of planar graphs to $33$. As a corollary, bipartite planar graphs have queue number at most $22$.

Authors: Sergey Pupyrev

A queue layout of a graph consists of a linear order of the vertices and a partition of the edges into queues so that no two edges in a single queue are nested. The minimum number of queues needed in a queue layout of a graph is called its queue number. A planar product structure theorem of Dujmović, Joret, Micek, Morin, Ueckerdt, and Wood (JACM, 2020) states that every planar graph is a subgraph of the strong product of a graph of simple treewidth at most $3$, a clique $K_3$, and a path. The result has been used to show that the queue number of planar graphs is at most $49$. Recently, Bekos, Gronemann, and Raftopoulou (Algorithmica, 2023) investigated how the general approach based on the product structure can be optimized for planar graphs. They claim that an appropriate reordering of the three vertices associated with each bag in the product structure decomposition, called a tripod, reduces the queue number of planar graphs to $42$. We first highlight a gap in their queue layout algorithm: one of the choices required by the algorithm is not guaranteed to exist. Then we show how to address the limitation and provide an alternative tripod reordering mechanism that reduces the upper bound on the queue number of planar graphs to $33$. As a corollary, bipartite planar graphs have queue number at most $22$.

Small Maximum Likelihood on Fixed Cavender-Farris-Neyman Trees: An Approximation Scheme and Limits to Fully Polynomial Approximation

from arXiv: Data Structures and Algorithms

Authors: Mohammad-Hadi Foroughmand-Araabi, Sama Goliaei

Small Maximum Likelihood fits the edge substitution probabilities of a given phylogenetic tree to an observed alignment, summing over the unobserved ancestral states. For the binary Cavender--Farris--Neyman model, we assume a uniform root and an edge-specific substitution probability $p_e\in[0,\tfrac12]$ for each edge $e$, shared across all alignment sites. We give a deterministic polynomial-time approximation scheme. The algorithm achieves a factor of $1+\varepsilon$ for both the negative log likelihood and the loss after subtracting the uniform-root contribution. Its main step fixes ancestral sequences at one periodically spaced class of depths while summing over all remaining ancestors. A posterior entropy bound controls the cost of this restriction, and dynamic programming optimizes the resulting components over a finite parameter grid. We also give a randomized reduction from Clique showing that an FPTAS returning feasible rational edge probabilities would imply $RP=NP$. These results separate fixed-accuracy approximation from fully polynomial approximation for the same fixed-tree model.

Authors: Mohammad-Hadi Foroughmand-Araabi, Sama Goliaei

Small Maximum Likelihood fits the edge substitution probabilities of a given phylogenetic tree to an observed alignment, summing over the unobserved ancestral states. For the binary Cavender--Farris--Neyman model, we assume a uniform root and an edge-specific substitution probability $p_e\in[0,\tfrac12]$ for each edge $e$, shared across all alignment sites. We give a deterministic polynomial-time approximation scheme. The algorithm achieves a factor of $1+\varepsilon$ for both the negative log likelihood and the loss after subtracting the uniform-root contribution. Its main step fixes ancestral sequences at one periodically spaced class of depths while summing over all remaining ancestors. A posterior entropy bound controls the cost of this restriction, and dynamic programming optimizes the resulting components over a finite parameter grid. We also give a randomized reduction from Clique showing that an FPTAS returning feasible rational edge probabilities would imply $RP=NP$. These results separate fixed-accuracy approximation from fully polynomial approximation for the same fixed-tree model.

Tokenization: Hardness and Bicriteria Approximation Algorithms

from arXiv: Data Structures and Algorithms

Authors: Atieh Bastan, Xiaoling He, A. Pavan, N. V. Vinodchandran

We study Binary Tokenization: given a corpus of binary strings over $\{0,1\}$ and a vocabulary budget $K$, select at most $K$ substrings (called vocabulary) to minimize the total number of tokens needed to represent the corpus. The primitive symbols $0$ and $1$ are always available, and each document must be segmented separately. Letting $n$ denote the total corpus length and $M$ for the maximum document length, we prove that, for every fixed $\varepsilon\in(0,1)$, Binary Tokenization problem does not have polynomial-time $n^{1-\varepsilon}$-approximation algorithms unless $\mathsf{P}=\mathsf{NP}$. To complement the hardness result, we give a polynomial-time $(γ,γ)$-bicriteria algorithm, with $γ= \sqrt{M}\log n$: The algorithm outputs a vocabulary of size at most $γK$ with number of tokens at most $γ{\rm OPT}_K$, where ${\rm OPT}_K$ is the optimal number of tokens under the original budget $K$. We also study a storage-budget variant, in which the sum of the selected substrings' lengths is bounded by $B$. For $2\le B

Authors: Atieh Bastan, Xiaoling He, A. Pavan, N. V. Vinodchandran

We study Binary Tokenization: given a corpus of binary strings over $\{0,1\}$ and a vocabulary budget $K$, select at most $K$ substrings (called vocabulary) to minimize the total number of tokens needed to represent the corpus. The primitive symbols $0$ and $1$ are always available, and each document must be segmented separately. Letting $n$ denote the total corpus length and $M$ for the maximum document length, we prove that, for every fixed $\varepsilon\in(0,1)$, Binary Tokenization problem does not have polynomial-time $n^{1-\varepsilon}$-approximation algorithms unless $\mathsf{P}=\mathsf{NP}$. To complement the hardness result, we give a polynomial-time $(γ,γ)$-bicriteria algorithm, with $γ= \sqrt{M}\log n$: The algorithm outputs a vocabulary of size at most $γK$ with number of tokens at most $γ{\rm OPT}_K$, where ${\rm OPT}_K$ is the optimal number of tokens under the original budget $K$. We also study a storage-budget variant, in which the sum of the selected substrings' lengths is bounded by $B$. For $2\le B

Bounded Knapsack in Truly Subquadratic Time

from arXiv: Data Structures and Algorithms

Authors: Huanyi Zhou

Bounded Knapsack asks how many copies of each item to take to maximize profit under a capacity constraint. Given $n$ records with binary-encoded multiplicities, we return optimal counts in randomized time with a fixed power saving in the maximum item weight $w_{\max}$ or maximum item profit $p_{\max}$. Fix $1<ρ<2$ and suppose integer $(\min,+)$-convolution on length-$m$ arrays can be computed with failure probability at most $η$ in $\widetilde O(m^ρ)$ time, up to polynomial factors in the entry bit length and $\log(1/η)$. Put $f(ρ)=4(3-ρ)/(8-3ρ).$ For any fixed $ε>0$, on inputs whose integers have magnitude polynomial in $n+\min(w_{\max},p_{\max})$, our algorithm runs in time $$\widetilde O\bigl(n\min(w_{\max},p_{\max})^{f(ρ)+ε}\bigr).$$ It returns optimal counts with high probability. If convolution saves $δ=2-ρ$ in its exponent, knapsack retains $δ/(1+3δ/2)$. With the integer convolution exponent $1.9601397040925$, a separate parameter choice gives $\widetilde O(n+\min(w_{\max},p_{\max})^{1.961})$, including for 0-1 Knapsack. We keep the copies compressed. Witnessed convolutions generate residual queries, and local linear programs filter them by cost. Resilient lattice cores allow recursive states to coalesce. Progression reserves support rounding, and a thin affordable fiber yields a lift that reduces the normalized column volume. This volume bounds the number of LP regions a grid lookup examines.

Authors: Huanyi Zhou

Bounded Knapsack asks how many copies of each item to take to maximize profit under a capacity constraint. Given $n$ records with binary-encoded multiplicities, we return optimal counts in randomized time with a fixed power saving in the maximum item weight $w_{\max}$ or maximum item profit $p_{\max}$. Fix $1<ρ<2$ and suppose integer $(\min,+)$-convolution on length-$m$ arrays can be computed with failure probability at most $η$ in $\widetilde O(m^ρ)$ time, up to polynomial factors in the entry bit length and $\log(1/η)$. Put $f(ρ)=4(3-ρ)/(8-3ρ).$ For any fixed $ε>0$, on inputs whose integers have magnitude polynomial in $n+\min(w_{\max},p_{\max})$, our algorithm runs in time $$\widetilde O\bigl(n\min(w_{\max},p_{\max})^{f(ρ)+ε}\bigr).$$ It returns optimal counts with high probability. If convolution saves $δ=2-ρ$ in its exponent, knapsack retains $δ/(1+3δ/2)$. With the integer convolution exponent $1.9601397040925$, a separate parameter choice gives $\widetilde O(n+\min(w_{\max},p_{\max})^{1.961})$, including for 0-1 Knapsack. We keep the copies compressed. Witnessed convolutions generate residual queries, and local linear programs filter them by cost. Resilient lattice cores allow recursive states to coalesce. Progression reserves support rounding, and a thin affordable fiber yields a lift that reduces the normalized column volume. This volume bounds the number of LP regions a grid lookup examines.

Sharp Lower Bounds for Parallel Log-Concave Sampling

from arXiv: Data Structures and Algorithms

Authors: Evan Dogariu

How many rounds of parallel queries are needed to sample from a smooth, strongly log-concave distribution on $\mathbb{R}^d$? For every fixed condition number $κ\in (1, \infty)$, we prove that any sampler making polynomially many queries per round requires $Ω_κ(\log d)$ rounds to achieve constant total variation error in the worst case. The lower bound holds even if queries return derivatives of all orders. Together with the first-order parallel Picard algorithm of \cite{zhou2025parallel}, this establishes a depth complexity of $Θ_κ(\log d)$ for parallel log-concave sampling with $\operatorname{poly}(d)$ width. We then study centered Gaussian targets to understand how much width is needed at a given depth. From \cite{chewi2023query,zhou2026complexitygaussiansampling}, it is known that either one round of width $d$ or $\mathcal{O}(\sqrtκ \log d)$ rounds of constant width suffice for first-order Gaussian sampling. At fixed $κ$ we characterize the depth-width tradeoff interpolating between these regimes: when using $ \lceil c \log d\rceil$ rounds, if $0 < c < c_\star(κ)$ then the optimal width at constant TV error is $\widetildeΘ(d^{1-c/c_\star(κ)})$, while if $c \geq c_\star(κ)$ then it is $Θ_κ(1)$. Here, $c_\star(κ)$ is an explicit constant with $c_\star(κ) \sim \sqrtκ / 8$ as $κ\to \infty$.

Authors: Evan Dogariu

How many rounds of parallel queries are needed to sample from a smooth, strongly log-concave distribution on $\mathbb{R}^d$? For every fixed condition number $κ\in (1, \infty)$, we prove that any sampler making polynomially many queries per round requires $Ω_κ(\log d)$ rounds to achieve constant total variation error in the worst case. The lower bound holds even if queries return derivatives of all orders. Together with the first-order parallel Picard algorithm of \cite{zhou2025parallel}, this establishes a depth complexity of $Θ_κ(\log d)$ for parallel log-concave sampling with $\operatorname{poly}(d)$ width. We then study centered Gaussian targets to understand how much width is needed at a given depth. From \cite{chewi2023query,zhou2026complexitygaussiansampling}, it is known that either one round of width $d$ or $\mathcal{O}(\sqrtκ \log d)$ rounds of constant width suffice for first-order Gaussian sampling. At fixed $κ$ we characterize the depth-width tradeoff interpolating between these regimes: when using $ \lceil c \log d\rceil$ rounds, if $0 < c < c_\star(κ)$ then the optimal width at constant TV error is $\widetildeΘ(d^{1-c/c_\star(κ)})$, while if $c \geq c_\star(κ)$ then it is $Θ_κ(1)$. Here, $c_\star(κ)$ is an explicit constant with $c_\star(κ) \sim \sqrtκ / 8$ as $κ\to \infty$.

Conflict-Free Cuts: Exploring the Boundaries of Tractability

from arXiv: Data Structures and Algorithms

Authors: Subrahmanyam Kalyanasundaram, Subodh Kumar

A conflict-free cut of a host graph $G$ is an edge cut containing no conflicting pair of edges. The conflicts are specified by a conflict graph $\widehat G$ whose vertex set is $E(G)$. The conflict-free cut problem asks if the given instance $(G, \widehat G)$ has a conflict-free cut. When restricted to planar $G$ and 1-regular $\widehat G$, the problem is polynomial time solvable when $G$ has maximum degree 4, but NP-complete already at maximum degree 5. We study the complexity of conflict-free cut problem under restrictions on the degrees of $G$, the components of $\widehat G$, and the locality of the conflicts. A conflict is local if its two edges share an endpoint in $G$. We prove the following results. * For $Δ(\widehat G)\le1$, a directed-cycle formulation gives a polynomial-time algorithm when $|E(G)|\le2|V(G)|$, hence for maximum degree four. The problem is NP-complete on $5$-regular hosts with exactly $1$-regular conflicts. * For $Δ(\widehat G)\le1$, we give a constructive FPT algorithm in $s_4(G)=\sum_v\max\{0,d_G(v)-4\}$, single-exponential for planar hosts. For arbitrary conflicts, we give an XP algorithm in $η=\max\{0,|E(\widehat G)|-|V(G)|\}$. * On $4$-regular hosts, local exactly $2$-regular conflicts with components $C_3,C_4$ give NP-completeness. For local conflicts at maximum degree four, pair or triangle components separately permit polynomial algorithms, but mixing them gives NP-completeness. We classify cases where $\widehat G$ is a union of cliques. * An $a$-COC is a vertex set whose deletion leaves components of order at most $a$. For local conflicts, the problem is FPT in the minimum $2$-COC size, but NP-complete with a supplied $3$-COC of size six. Without locality, hardness holds with a supplied $2$-COC of size six. Both hardness results use exactly $1$-regular conflicts.

Authors: Subrahmanyam Kalyanasundaram, Subodh Kumar

A conflict-free cut of a host graph $G$ is an edge cut containing no conflicting pair of edges. The conflicts are specified by a conflict graph $\widehat G$ whose vertex set is $E(G)$. The conflict-free cut problem asks if the given instance $(G, \widehat G)$ has a conflict-free cut. When restricted to planar $G$ and 1-regular $\widehat G$, the problem is polynomial time solvable when $G$ has maximum degree 4, but NP-complete already at maximum degree 5. We study the complexity of conflict-free cut problem under restrictions on the degrees of $G$, the components of $\widehat G$, and the locality of the conflicts. A conflict is local if its two edges share an endpoint in $G$. We prove the following results. * For $Δ(\widehat G)\le1$, a directed-cycle formulation gives a polynomial-time algorithm when $|E(G)|\le2|V(G)|$, hence for maximum degree four. The problem is NP-complete on $5$-regular hosts with exactly $1$-regular conflicts. * For $Δ(\widehat G)\le1$, we give a constructive FPT algorithm in $s_4(G)=\sum_v\max\{0,d_G(v)-4\}$, single-exponential for planar hosts. For arbitrary conflicts, we give an XP algorithm in $η=\max\{0,|E(\widehat G)|-|V(G)|\}$. * On $4$-regular hosts, local exactly $2$-regular conflicts with components $C_3,C_4$ give NP-completeness. For local conflicts at maximum degree four, pair or triangle components separately permit polynomial algorithms, but mixing them gives NP-completeness. We classify cases where $\widehat G$ is a union of cliques. * An $a$-COC is a vertex set whose deletion leaves components of order at most $a$. For local conflicts, the problem is FPT in the minimum $2$-COC size, but NP-complete with a supplied $3$-COC of size six. Without locality, hardness holds with a supplied $2$-COC of size six. Both hardness results use exactly $1$-regular conflicts.

A Faster Scaling Algorithm for Maximum Weight Matroid Intersection

from arXiv: Data Structures and Algorithms

Authors: Alina Ene, Huy L. Nguyen

We consider the maximum weight matroid intersection problem. In this problem, we are given two matroids $M_{1}=(E,\mathcal{I}_{1})$ and $M_{2}=(E,\mathcal{I}_{2})$ and integer weights $w(e)$ on the elements $e\in E$, and the goal is to find a maximum-weight common independent set. We give a randomized algorithm that constructs an optimal solution using $\widetilde{O}(nr\log W)$ queries to the independence oracles of the matroids, where $n$ is the size of the ground set $E$, $r$ is the minimum rank of the two matroids, and $W$ is the maximum weight.

Authors: Alina Ene, Huy L. Nguyen

We consider the maximum weight matroid intersection problem. In this problem, we are given two matroids $M_{1}=(E,\mathcal{I}_{1})$ and $M_{2}=(E,\mathcal{I}_{2})$ and integer weights $w(e)$ on the elements $e\in E$, and the goal is to find a maximum-weight common independent set. We give a randomized algorithm that constructs an optimal solution using $\widetilde{O}(nr\log W)$ queries to the independence oracles of the matroids, where $n$ is the size of the ground set $E$, $r$ is the minimum rank of the two matroids, and $W$ is the maximum weight.

Tree Decomposition of Product and Nest Graphs for Assortment Optimization under the Generalized Nested Logit Model

from arXiv: Data Structures and Algorithms

Authors: Yuheng Wang, Paat Rusmevichientong, Huseyin Topaloglu

The generalized nested logit model extends the nested logit model by allowing each product to belong to multiple nests. The overlapping nests in the generalized nested logit model can capture complex substitution patterns, and the model has found applications in many areas. We study the assortment optimization problem under the generalized nested logit model and prove that it is NP-hard when there are only two nests or when any two distinct nests have at most one product in common. Motivated by these complexity results, we introduce novel concepts of product and nest graphs that capture which products are included in which nests. We use the tree decompositions of the graphs to characterize when the assortment optimization problem admits efficient solution methods. When the treewidth of a product graph is bounded, the assortment optimization problem can be solved in polynomial time. If the treewidth of the product graph is unbounded but the treewidth of the nest graph is bounded, then there exists a fully polynomial-time approximation scheme. These results represent the first polynomial-time algorithms for assortment optimization under the generalized nested logit model. Our numerical experiments on synthetic and real datasets show that the generalized nested logit model provides a better fit to the data than many existing models in the literature.

Authors: Yuheng Wang, Paat Rusmevichientong, Huseyin Topaloglu

The generalized nested logit model extends the nested logit model by allowing each product to belong to multiple nests. The overlapping nests in the generalized nested logit model can capture complex substitution patterns, and the model has found applications in many areas. We study the assortment optimization problem under the generalized nested logit model and prove that it is NP-hard when there are only two nests or when any two distinct nests have at most one product in common. Motivated by these complexity results, we introduce novel concepts of product and nest graphs that capture which products are included in which nests. We use the tree decompositions of the graphs to characterize when the assortment optimization problem admits efficient solution methods. When the treewidth of a product graph is bounded, the assortment optimization problem can be solved in polynomial time. If the treewidth of the product graph is unbounded but the treewidth of the nest graph is bounded, then there exists a fully polynomial-time approximation scheme. These results represent the first polynomial-time algorithms for assortment optimization under the generalized nested logit model. Our numerical experiments on synthetic and real datasets show that the generalized nested logit model provides a better fit to the data than many existing models in the literature.

Multiple-Choice Knapsack with Small Items

from arXiv: Data Structures and Algorithms

Authors: Jakub Pawlewicz

The Multiple-Choice Knapsack problem is a generalization of the Knapsack problem in which items are partitioned into disjoint classes and exactly one item must be selected from each class. Besides the standard dynamic program running in time $\mathcal{O}(nc)$, where $n$ is the total number of items and $c$ is the knapsack capacity, no other pseudopolynomial-time algorithm is currently known. We present an $\mathcal{O}(n+w_{\max}^4)$-time algorithm, where $w_{\max}=\max_i (w_{in_i}-w_{i1})$ is the maximum weight range within a class.

Authors: Jakub Pawlewicz

The Multiple-Choice Knapsack problem is a generalization of the Knapsack problem in which items are partitioned into disjoint classes and exactly one item must be selected from each class. Besides the standard dynamic program running in time $\mathcal{O}(nc)$, where $n$ is the total number of items and $c$ is the knapsack capacity, no other pseudopolynomial-time algorithm is currently known. We present an $\mathcal{O}(n+w_{\max}^4)$-time algorithm, where $w_{\max}=\max_i (w_{in_i}-w_{i1})$ is the maximum weight range within a class.

Minimizing Monotone Norms in Fractional Load Balancing

from arXiv: Data Structures and Algorithms

Authors: Daniel Blankenburg, Antonia Ellerbrock, Thomas Kesselheim, Jens Vygen

We devise a fully polynomial time approximation scheme for minimizing a monotone norm $\left\lVert\cdot\right\rVert$ over a convex set $X\subseteq \mathbb{R}^d_{\geq 0}$. We study the multi-customer setting, where $X=\sum_{i=1}^n X_i$ and the solution set $X_i\subseteq \mathbb{R}^d_{\geq 0}$ is given by a linear minimization oracle for each customer $i$. Our algorithm computes, for any given $\varepsilon>0$, a $(1+\varepsilon)$-approximate solution. With high probability, it uses $\tilde{\mathcal{O}}\left( \varepsilon^{-2}(n+d) \right)$ single-customer linear minimization oracle calls and the same number of generalized KL projections to the dual space $Y=\{y\in \mathbb{R}^d_{\geq 0}: \left\lVert y \right\rVert^* \le 1\}$. We assume no prior knowledge on $X$, and our running time depends only on $n$, $d$, and $\varepsilon$. Our result is robust in the sense that it allows for approximate linear minimization oracles and approximate KL projections. We show that the (approximate) KL projection can be performed efficiently for large classes of monotone norms, demonstrating the applicability of our approach. While such a result (with exact projection) is well-known for the $\ell_{\infty}$ norm via multiplicative weight updates and was recently obtained for ordered norms via a smooth norm approximation and a novel randomization, existing techniques do not extend to general monotone norms. In particular, a key feature used in previous proofs was dual price stability, which was derived from a global contraction property of the KL projection to the dual space $Y$. We show that this property does not extend to general monotone norms. Therefore, we use a different price mechanism, based on the well-known mirror descent paradigm, for which a local contraction property holds and guarantees stability.

Authors: Daniel Blankenburg, Antonia Ellerbrock, Thomas Kesselheim, Jens Vygen

We devise a fully polynomial time approximation scheme for minimizing a monotone norm $\left\lVert\cdot\right\rVert$ over a convex set $X\subseteq \mathbb{R}^d_{\geq 0}$. We study the multi-customer setting, where $X=\sum_{i=1}^n X_i$ and the solution set $X_i\subseteq \mathbb{R}^d_{\geq 0}$ is given by a linear minimization oracle for each customer $i$. Our algorithm computes, for any given $\varepsilon>0$, a $(1+\varepsilon)$-approximate solution. With high probability, it uses $\tilde{\mathcal{O}}\left( \varepsilon^{-2}(n+d) \right)$ single-customer linear minimization oracle calls and the same number of generalized KL projections to the dual space $Y=\{y\in \mathbb{R}^d_{\geq 0}: \left\lVert y \right\rVert^* \le 1\}$. We assume no prior knowledge on $X$, and our running time depends only on $n$, $d$, and $\varepsilon$. Our result is robust in the sense that it allows for approximate linear minimization oracles and approximate KL projections. We show that the (approximate) KL projection can be performed efficiently for large classes of monotone norms, demonstrating the applicability of our approach. While such a result (with exact projection) is well-known for the $\ell_{\infty}$ norm via multiplicative weight updates and was recently obtained for ordered norms via a smooth norm approximation and a novel randomization, existing techniques do not extend to general monotone norms. In particular, a key feature used in previous proofs was dual price stability, which was derived from a global contraction property of the KL projection to the dual space $Y$. We show that this property does not extend to general monotone norms. Therefore, we use a different price mechanism, based on the well-known mirror descent paradigm, for which a local contraction property holds and guarantees stability.

Beyond Worst-Case Online Algorithms via Input Subsampling

from arXiv: Data Structures and Algorithms

Authors: Siddhartha Banerjee, Tianle Jiang, Kamesh Munagala

We study whether classical competitive ratios survive input subsampling, when both the online algorithm and the offline optimum are evaluated on the same subsampled input. We consider the canonical problems of prophet inequalities and ski-rental. In these settings, for any single subsampling rate, the classical worst-case ratios remain unchanged. We ask a stronger question: can one adversarial input remain worst-case at two distinct rates $p>q$? For prophet inequalities, in the model where the policy knows the sampling rate and learns item survival online, every instance has competitive ratio strictly below $2$ at one of the two rates, and we determine the tight simultaneous guarantee. For ski rental, in the fluid model where sampling scales the horizon, the answer depends on $q/p$. Against adversarial distributions over horizons, one unrestricted randomized algorithm achieves a strict simultaneous improvement over $e/(e-1)$ for every distribution exactly when $q/p$ is below approximately $0.34$. Requiring the algorithm to buy by the breakeven time lowers this threshold to approximately $0.31$, showing that unlike classical ski-rental algorithms, buying later can provably help in this setting. Our results therefore reveal a new form of beyond-worst-case fragility under input subsampling: instances that are worst-case at one rate need not remain hard at two rates simultaneously.

Authors: Siddhartha Banerjee, Tianle Jiang, Kamesh Munagala

We study whether classical competitive ratios survive input subsampling, when both the online algorithm and the offline optimum are evaluated on the same subsampled input. We consider the canonical problems of prophet inequalities and ski-rental. In these settings, for any single subsampling rate, the classical worst-case ratios remain unchanged. We ask a stronger question: can one adversarial input remain worst-case at two distinct rates $p>q$? For prophet inequalities, in the model where the policy knows the sampling rate and learns item survival online, every instance has competitive ratio strictly below $2$ at one of the two rates, and we determine the tight simultaneous guarantee. For ski rental, in the fluid model where sampling scales the horizon, the answer depends on $q/p$. Against adversarial distributions over horizons, one unrestricted randomized algorithm achieves a strict simultaneous improvement over $e/(e-1)$ for every distribution exactly when $q/p$ is below approximately $0.34$. Requiring the algorithm to buy by the breakeven time lowers this threshold to approximately $0.31$, showing that unlike classical ski-rental algorithms, buying later can provably help in this setting. Our results therefore reveal a new form of beyond-worst-case fragility under input subsampling: instances that are worst-case at one rate need not remain hard at two rates simultaneously.

Optimal-Time Independent Subset Sampling over Acyclic Joins

from arXiv: Data Structures and Algorithms

Authors: Xuyang Liu, Zijian Zhang, Zhen Li

Join results can greatly exceed their inputs even when applications need only a small random subset. We study sampling that includes each result independently with a prescribed probability given by the product of its input-tuple weights (PRODUCT). For fixed full acyclic joins with static weights, we achieve input-linear preprocessing and index space together with output-linear expected sampling work, eliminating logarithmic factors from previous bounds. A shared join-tree index supports weighted draws over the entire join and locates high-probability results. Direct Bernoulli trials handle high-probability results, allowing Poisson thinning to generate the remaining independent inclusion decisions with bounded overhead. Our exact sampler uses expected $O(N)$ preprocessing, $O(N)$ index space, and expected $O(1+mμ)$ time per call including output construction. Here $N$ is the input size, $m$ counts relation occurrences, and $μ$ is the expected sample size. The guarantees hold on a real random-access machine with unit-cost exact arithmetic and logarithms, continuous uniform randomness, and expected-time hashing. The time bounds are optimal, matching input reading and explicit output writing. Our floating-point prototype has lower sampling latency than the fastest applicable baseline in 17 of 18 PRODUCT settings on three queries over the STATS benchmark. Construction savings on large joins can offset indexed materialization's faster sampling over a limited number of calls. On a real-data path at $μ=100$, our sampler achieves a $20.5\times$ speedup over indexed materialization for construction plus 300 calls, measured after common data preparation and loading.

Authors: Xuyang Liu, Zijian Zhang, Zhen Li

Join results can greatly exceed their inputs even when applications need only a small random subset. We study sampling that includes each result independently with a prescribed probability given by the product of its input-tuple weights (PRODUCT). For fixed full acyclic joins with static weights, we achieve input-linear preprocessing and index space together with output-linear expected sampling work, eliminating logarithmic factors from previous bounds. A shared join-tree index supports weighted draws over the entire join and locates high-probability results. Direct Bernoulli trials handle high-probability results, allowing Poisson thinning to generate the remaining independent inclusion decisions with bounded overhead. Our exact sampler uses expected $O(N)$ preprocessing, $O(N)$ index space, and expected $O(1+mμ)$ time per call including output construction. Here $N$ is the input size, $m$ counts relation occurrences, and $μ$ is the expected sample size. The guarantees hold on a real random-access machine with unit-cost exact arithmetic and logarithms, continuous uniform randomness, and expected-time hashing. The time bounds are optimal, matching input reading and explicit output writing. Our floating-point prototype has lower sampling latency than the fastest applicable baseline in 17 of 18 PRODUCT settings on three queries over the STATS benchmark. Construction savings on large joins can offset indexed materialization's faster sampling over a limited number of calls. On a real-data path at $μ=100$, our sampler achieves a $20.5\times$ speedup over indexed materialization for construction plus 300 calls, measured after common data preparation and loading.

Online Vertex Connectivity Augmentation

from arXiv: Data Structures and Algorithms

Authors: Yaowei Long, Sepideh Mahabadi, Jakub Tarnawski

Network design problems form a classic subfield of online algorithms, but almost nothing is known about their more challenging vertex-connectivity variants. We initiate the study of online vertex-connectivity network design for arbitrary demand pairs by considering the fundamental problem of connectivity augmentation. In an instance of \emph{Online Vertex Connectivity Augmentation} (OVCA), we are given a $k$-vertex-connected graph $F$ and a set of additional purchasable edges (with costs). Demand pairs $(s_1,t_1),(s_2,t_2),\dots$ then arrive online. Upon each arrival, the algorithm must irrevocably purchase edges so that $s_i$ and $t_i$ become $(k{+}1)$-vertex-connected in the union of $F$ with all edges purchased so far. Our main contribution is an $O((k+\log n)\log n)$-competitive online algorithm for OVCA. We also give an offline $O(k+\log n)$-approximation algorithm. We obtain our algorithms via a structural dichotomy on the minimum vertex cuts of $F$. We note that some dependence on $k$ in the approximation ratio is necessary -- i.e., the problem is hard to approximate within any $\mathrm{polylog}(n)$ factor independent of $k$ -- which shows a separation from the edge-connectivity setting. Finally, specializing to $k=1$, our methods yield the first polylogarithmic-competitive online algorithm for a vertex-connectivity survivable network design problem, namely an $\widetilde O(\log^3 n)$-competitive algorithm for online $\{1,2\}$-VC-SNDP (i.e., an SNDP variant where each demand pair comes with a vertex-connectivity requirement of $1$ or $2$).

Authors: Yaowei Long, Sepideh Mahabadi, Jakub Tarnawski

Network design problems form a classic subfield of online algorithms, but almost nothing is known about their more challenging vertex-connectivity variants. We initiate the study of online vertex-connectivity network design for arbitrary demand pairs by considering the fundamental problem of connectivity augmentation. In an instance of \emph{Online Vertex Connectivity Augmentation} (OVCA), we are given a $k$-vertex-connected graph $F$ and a set of additional purchasable edges (with costs). Demand pairs $(s_1,t_1),(s_2,t_2),\dots$ then arrive online. Upon each arrival, the algorithm must irrevocably purchase edges so that $s_i$ and $t_i$ become $(k{+}1)$-vertex-connected in the union of $F$ with all edges purchased so far. Our main contribution is an $O((k+\log n)\log n)$-competitive online algorithm for OVCA. We also give an offline $O(k+\log n)$-approximation algorithm. We obtain our algorithms via a structural dichotomy on the minimum vertex cuts of $F$. We note that some dependence on $k$ in the approximation ratio is necessary -- i.e., the problem is hard to approximate within any $\mathrm{polylog}(n)$ factor independent of $k$ -- which shows a separation from the edge-connectivity setting. Finally, specializing to $k=1$, our methods yield the first polylogarithmic-competitive online algorithm for a vertex-connectivity survivable network design problem, namely an $\widetilde O(\log^3 n)$-competitive algorithm for online $\{1,2\}$-VC-SNDP (i.e., an SNDP variant where each demand pair comes with a vertex-connectivity requirement of $1$ or $2$).

A Parallel Greedy Algorithm for Maximal b-Matching in Hypergraphs

from arXiv: Data Structures and Algorithms

Authors: Saeed Bakhshan, Daniel Grosu, Henrik Reinstädtler, Christian Schulz

We present \parallelBatchBMatch, a parallel batch-vote algorithm for maximal $b$-matching in hypergraphs. The algorithm is deterministic for a given ordering of edges and produces the same output as the sequential greedy algorithm, i.e., the lexicographically first maximal $b$-matching. Under a uniformly random priority order it performs $O(m')$ expected work in the binary fork--join model, where $m'$ is the number of pins, the total number of vertex--edge incidences. The algorithm performs at most $m$ rounds for every priority order, where $m$ is the number of edges. Every round of the algorithm has $O(\log^2 m')$ depth with high probability, and thus the total depth of the algorithm is $O(m \log^2 m')$ with high probability. We implement the parallel algorithm in CUDA and evaluate it on real-world hypergraphs with capacities $b \in \{1, 3, 5\}$. The parallel algorithm computes the same matchings as the greedy algorithms and for the case of $b = 5$ it is up to $19.07$ times faster than the existing state-of-the art greedy algorithm.

Authors: Saeed Bakhshan, Daniel Grosu, Henrik Reinstädtler, Christian Schulz

We present \parallelBatchBMatch, a parallel batch-vote algorithm for maximal $b$-matching in hypergraphs. The algorithm is deterministic for a given ordering of edges and produces the same output as the sequential greedy algorithm, i.e., the lexicographically first maximal $b$-matching. Under a uniformly random priority order it performs $O(m')$ expected work in the binary fork--join model, where $m'$ is the number of pins, the total number of vertex--edge incidences. The algorithm performs at most $m$ rounds for every priority order, where $m$ is the number of edges. Every round of the algorithm has $O(\log^2 m')$ depth with high probability, and thus the total depth of the algorithm is $O(m \log^2 m')$ with high probability. We implement the parallel algorithm in CUDA and evaluate it on real-world hypergraphs with capacities $b \in \{1, 3, 5\}$. The parallel algorithm computes the same matchings as the greedy algorithms and for the case of $b = 5$ it is up to $19.07$ times faster than the existing state-of-the art greedy algorithm.

A polynomial-time approximation scheme for the weighted Euclidean Minimum Latency Problem in fixed dimension

from arXiv: Data Structures and Algorithms

Authors: Daniel Skachkov, Yuriy Dorn

In the Traveling Salesman Problem, a route must visit all customers and return to its starting point while minimizing its total length. The Minimum Latency Problem, also known as the Traveling Repairman Problem, instead minimizes the sum of the times at which customers are first visited. We give a deterministic polynomial-time approximation scheme for the weighted Euclidean Minimum Latency Problem in every fixed dimension, with arbitrary nonnegative customer weights. Our proof restricts the form of a solution in three steps, each with a controlled increase in cost. First, a decomposition based on Sitters' method assigns customers to phases that start and end at the root. Second, within each phase, we divide the route into a constant number of blocks and charge each customer at the end of its assigned block. The resulting objective is a nonnegative linear combination of block lengths. Third, we add an auxiliary dimension and use a fixed Minkowski norm to close each block path into a tour. Arora's closed-tour estimate then gives paths that cross the boundaries of a common dissection only at designated portals and a bounded number of times per face. A dynamic program optimizes the restricted objective, and projecting its paths back to the original space gives the final route. Rounding weights and coordinates keeps the state space polynomial.

Authors: Daniel Skachkov, Yuriy Dorn

In the Traveling Salesman Problem, a route must visit all customers and return to its starting point while minimizing its total length. The Minimum Latency Problem, also known as the Traveling Repairman Problem, instead minimizes the sum of the times at which customers are first visited. We give a deterministic polynomial-time approximation scheme for the weighted Euclidean Minimum Latency Problem in every fixed dimension, with arbitrary nonnegative customer weights. Our proof restricts the form of a solution in three steps, each with a controlled increase in cost. First, a decomposition based on Sitters' method assigns customers to phases that start and end at the root. Second, within each phase, we divide the route into a constant number of blocks and charge each customer at the end of its assigned block. The resulting objective is a nonnegative linear combination of block lengths. Third, we add an auxiliary dimension and use a fixed Minkowski norm to close each block path into a tour. Arora's closed-tour estimate then gives paths that cross the boundaries of a common dissection only at designated portals and a bounded number of times per face. A dynamic program optimizes the restricted objective, and projecting its paths back to the original space gives the final route. Rounding weights and coordinates keeps the state space polynomial.

Integrality Gap of 3.4 for Santa Claus: A Topology-based Analysis

from arXiv: Data Structures and Algorithms

Authors: Kimon Boehmer, Chien-Chung Huang

In the \textsc{Max-Min Allocation} problem, a set of indivisible items are to be assigned to a set of players and the goal is to maximize the minimum value among all players. A much studied special case, the \textsc{Santa Claus} problem, assumes that an item has a fixed utility but a player is only interested in a subset of items. The main technique for designing approximation algorithms for \textsc{Santa Claus} is the configuration LP, introduced by the Bansal and Sviridenko. A long line of research has progressively improved the upper bound of the integrality gap, mostly relying on the combinatorial arguments of Haxell for finding perfect matchings in certain hypergraphs. Remarkably, a recent paper of Haxell and Szabó (SODA '23) introduced a novel topology-based analysis, by which they are able to obtain the current best upper bound of $3.534$. In this work, we adapt the approach of Haxell and Szabó to analyze the integrality gap. The main new ingredient in our adaptation is that we stop the process of "edge explosions" in a graph used by Haxell and Szabó when it becomes too costly. This early termination of explosions, combined with a new lower bound on a topological connectivity parameter based on a theorem of Aharoni, Berger, and Meshulam, allows us to improve the integrality gap to $3.4$. Our analysis has the additional advantage of being simpler.

Authors: Kimon Boehmer, Chien-Chung Huang

In the \textsc{Max-Min Allocation} problem, a set of indivisible items are to be assigned to a set of players and the goal is to maximize the minimum value among all players. A much studied special case, the \textsc{Santa Claus} problem, assumes that an item has a fixed utility but a player is only interested in a subset of items. The main technique for designing approximation algorithms for \textsc{Santa Claus} is the configuration LP, introduced by the Bansal and Sviridenko. A long line of research has progressively improved the upper bound of the integrality gap, mostly relying on the combinatorial arguments of Haxell for finding perfect matchings in certain hypergraphs. Remarkably, a recent paper of Haxell and Szabó (SODA '23) introduced a novel topology-based analysis, by which they are able to obtain the current best upper bound of $3.534$. In this work, we adapt the approach of Haxell and Szabó to analyze the integrality gap. The main new ingredient in our adaptation is that we stop the process of "edge explosions" in a graph used by Haxell and Szabó when it becomes too costly. This early termination of explosions, combined with a new lower bound on a topological connectivity parameter based on a theorem of Aharoni, Berger, and Meshulam, allows us to improve the integrality gap to $3.4$. Our analysis has the additional advantage of being simpler.

Sparse Matrix Multiplication Exponent 1.5 in the Low-bandwidth Model

from arXiv: Data Structures and Algorithms

Authors: Chetan Gupta, Jukka Suomela, Hossein Vahidi

We study sparse matrix multiplication in the low-bandwidth model: $n$ computers multiply two $n\times n$ matrices, and each computer can send and receive one $O(\log n)$-bit message per round. The input matrices are uniformly sparse, meaning that there are at most $d$ nonzero entries in each row and column, and the task is to compute a uniformly sparse part of their product. In prior work, Gupta et al.~(SPAA 2022) presented an $O(d^{1.907})$-round algorithm over fields for this problem when the sparsity structure is globally known in advance (this is referred to as the supported setting). The upper bound was later improved to $O(d^{1.832})$ rounds. In this work, we give a deterministic algorithm that solves this problem in $O(d^{3/2})$ rounds in the supported setting, improving the previous bounds over fields and semirings.

Authors: Chetan Gupta, Jukka Suomela, Hossein Vahidi

We study sparse matrix multiplication in the low-bandwidth model: $n$ computers multiply two $n\times n$ matrices, and each computer can send and receive one $O(\log n)$-bit message per round. The input matrices are uniformly sparse, meaning that there are at most $d$ nonzero entries in each row and column, and the task is to compute a uniformly sparse part of their product. In prior work, Gupta et al.~(SPAA 2022) presented an $O(d^{1.907})$-round algorithm over fields for this problem when the sparsity structure is globally known in advance (this is referred to as the supported setting). The upper bound was later improved to $O(d^{1.832})$ rounds. In this work, we give a deterministic algorithm that solves this problem in $O(d^{3/2})$ rounds in the supported setting, improving the previous bounds over fields and semirings.

Speedup-Aware Rounding for Scheduling Malleable Tasks with Precedence Constraints

from arXiv: Data Structures and Algorithms

Authors: Chi-Yeh Chen

We study the scheduling of malleable tasks with precedence constraints on $m$ identical processors to minimize the makespan, assuming that the processing time of a task does not increase and its work does not decrease with the number of processors, and that the work is a convex function of the processing time. The standard two-phase method solves a linear program, rounds the fractional processing times to allotments, caps the allotments at a threshold $μ$, and runs list scheduling. We propose \emph{speedup-aware rounding}, which rounds a task to its slower allotment exactly when this allotment is at most a factor $a$ slower than the fractional processing time. We determine the worst-case increase of the work under this rule exactly and show that no per-task rounding rule with time factor $a$ does better. With $μ=\lceilβ(a)m\rceil$ the algorithm achieves the approximation ratio $13(30+\sqrt{493})/225\approx3.0162$ for every $m$, which improves the previous bound $2+\sqrt2\approx3.4142$; a single task with linear speedup shows that its ratio is at least $\approx2.9558$. For concave speedup functions, which include the roofline, communication, Amdahl and power-law models, the ratio becomes $\approx2.9739$, which improves the ratio $\approx3.2919$ of Jansen and Zhang. We also revisit the strictly decreasing case of our earlier work (Chen and Chu, 2013): the reported ratio $2.9549$ relies on an elimination step that is not valid. In this case the algorithm coincides with that of Jansen and Zhang up to its parameters, and with parameters chosen by the corrected analysis it guarantees their ratio $\approx3.2919$. Finally, without convexity no per-task rounding improves the known time--work trade-off, and the analysis cannot go below $(3+\sqrt5)/2$.

Authors: Chi-Yeh Chen

We study the scheduling of malleable tasks with precedence constraints on $m$ identical processors to minimize the makespan, assuming that the processing time of a task does not increase and its work does not decrease with the number of processors, and that the work is a convex function of the processing time. The standard two-phase method solves a linear program, rounds the fractional processing times to allotments, caps the allotments at a threshold $μ$, and runs list scheduling. We propose \emph{speedup-aware rounding}, which rounds a task to its slower allotment exactly when this allotment is at most a factor $a$ slower than the fractional processing time. We determine the worst-case increase of the work under this rule exactly and show that no per-task rounding rule with time factor $a$ does better. With $μ=\lceilβ(a)m\rceil$ the algorithm achieves the approximation ratio $13(30+\sqrt{493})/225\approx3.0162$ for every $m$, which improves the previous bound $2+\sqrt2\approx3.4142$; a single task with linear speedup shows that its ratio is at least $\approx2.9558$. For concave speedup functions, which include the roofline, communication, Amdahl and power-law models, the ratio becomes $\approx2.9739$, which improves the ratio $\approx3.2919$ of Jansen and Zhang. We also revisit the strictly decreasing case of our earlier work (Chen and Chu, 2013): the reported ratio $2.9549$ relies on an elimination step that is not valid. In this case the algorithm coincides with that of Jansen and Zhang up to its parameters, and with parameters chosen by the corrected analysis it guarantees their ratio $\approx3.2919$. Finally, without convexity no per-task rounding improves the known time--work trade-off, and the analysis cannot go below $(3+\sqrt5)/2$.

Parallel Spanning Forest and Biconnectivity for Well-Connected Graph in Sub-Logarithmic Time

from arXiv: Data Structures and Algorithms

Authors: Bojun Liu, S. Cliff Liu, Shuaibo Yang

We give a randomized ARBITRARY CRCW PRAM algorithm for computing a spanning forest of an \(n\)-vertex, \(m\)-edge graph. Let \(d\) be the maximum component diameter. With good probability, the algorithm runs in \(O(\log d+\log\log n)\) time using \(O(m+n)\) processors and outputs a rooted spanning forest of original edges with maximum depth \(2^{O(\log d+\log\log n)}\). For finding bridges, our algorithm identifies every bridge edge in \(O(\log d+\log\log n)\) time. For biconnectivity, it outputs all blocks in \(O(\log d+\log d'+\log\log n)\) time, where \(d'\) is the bi-diameter. All these problems are fundamental in graph algorithms with numerous applications. Our results improve the best previous time bounds parameterized by the number of vertices and diameter. Finally, we prove deterministic \(Ω(\log n/\log\log n)\) lower bounds for outputting a DFS Sequence, a weighted spanning forest, and an ear decomposition.

Authors: Bojun Liu, S. Cliff Liu, Shuaibo Yang

We give a randomized ARBITRARY CRCW PRAM algorithm for computing a spanning forest of an \(n\)-vertex, \(m\)-edge graph. Let \(d\) be the maximum component diameter. With good probability, the algorithm runs in \(O(\log d+\log\log n)\) time using \(O(m+n)\) processors and outputs a rooted spanning forest of original edges with maximum depth \(2^{O(\log d+\log\log n)}\). For finding bridges, our algorithm identifies every bridge edge in \(O(\log d+\log\log n)\) time. For biconnectivity, it outputs all blocks in \(O(\log d+\log d'+\log\log n)\) time, where \(d'\) is the bi-diameter. All these problems are fundamental in graph algorithms with numerous applications. Our results improve the best previous time bounds parameterized by the number of vertices and diameter. Finally, we prove deterministic \(Ω(\log n/\log\log n)\) lower bounds for outputting a DFS Sequence, a weighted spanning forest, and an ear decomposition.

Source Assignment: Hardness, Approximation, and Parameterized Algorithms

from arXiv: Data Structures and Algorithms

Authors: Ruxandra Marinescu-Ghemeci, Adrian Miclăuş, Alexandru Popa

In Source Assignment, each pointer represents a substring of a common reference string and may have several possible source occurrences. The goal is to choose one source for each pointer while minimizing the number of distinct reference boundaries used by the selected sources. The problem was introduced by Qiu and Kingsford (Bioinformatics 2021) in the context of compact genome-graph construction. We distinguish \emph{Explicit Source Assignment}, where admissible source sets are given explicitly, from \emph{Complete Source Assignment}, where all occurrences of each pointer string are available. We show that Explicit Source Assignment has an exact value-preserving formulation as cardinality Set Cover with Pairs. For every fixed $\varepsilon>0$, it cannot be approximated within $(1-\varepsilon)\ln p$ unless $\mathrm{P}=\mathrm{NP}$, even over a binary alphabet when all pointers have length one, while known algorithms for Minimum-Weight Multicolored Subgraph give an $O(\sqrt{q\log p})$-approximation for arbitrary pointer lengths. Our main hardness result proves that Complete Source Assignment is APX-hard even over a binary alphabet, with equal pointer lengths and at most two sources per pointer. For edge-disjoint equal-length instances, we give a $3/2$-approximation and a $1.12585$-approximation when each pointer has at most two sources. We also introduce the rainbow-path length $λ$: the problem is polynomial-time solvable for $λ\le2$, and for $λ\le3$ we obtain a $(9/8+\varepsilon)$-approximation. We further give a polynomial-time test for deciding whether abstract source sets can be realized exactly as complete occurrence sets over an unrestricted alphabet. Finally, we give exact fixed-parameter algorithms for several structural parameters, and show that Complete Source Assignment is fixed-parameter tractable in the alphabet size and maximum pointer length.

Authors: Ruxandra Marinescu-Ghemeci, Adrian Miclăuş, Alexandru Popa

In Source Assignment, each pointer represents a substring of a common reference string and may have several possible source occurrences. The goal is to choose one source for each pointer while minimizing the number of distinct reference boundaries used by the selected sources. The problem was introduced by Qiu and Kingsford (Bioinformatics 2021) in the context of compact genome-graph construction. We distinguish \emph{Explicit Source Assignment}, where admissible source sets are given explicitly, from \emph{Complete Source Assignment}, where all occurrences of each pointer string are available. We show that Explicit Source Assignment has an exact value-preserving formulation as cardinality Set Cover with Pairs. For every fixed $\varepsilon>0$, it cannot be approximated within $(1-\varepsilon)\ln p$ unless $\mathrm{P}=\mathrm{NP}$, even over a binary alphabet when all pointers have length one, while known algorithms for Minimum-Weight Multicolored Subgraph give an $O(\sqrt{q\log p})$-approximation for arbitrary pointer lengths. Our main hardness result proves that Complete Source Assignment is APX-hard even over a binary alphabet, with equal pointer lengths and at most two sources per pointer. For edge-disjoint equal-length instances, we give a $3/2$-approximation and a $1.12585$-approximation when each pointer has at most two sources. We also introduce the rainbow-path length $λ$: the problem is polynomial-time solvable for $λ\le2$, and for $λ\le3$ we obtain a $(9/8+\varepsilon)$-approximation. We further give a polynomial-time test for deciding whether abstract source sets can be realized exactly as complete occurrence sets over an unrestricted alphabet. Finally, we give exact fixed-parameter algorithms for several structural parameters, and show that Complete Source Assignment is fixed-parameter tractable in the alphabet size and maximum pointer length.

A Sublogarithmic Competitive Algorithm for Online Graph Exploration

from arXiv: Data Structures and Algorithms

Authors: Max Klimm

In online graph exploration, an agent must visit every vertex of an unknown weighted graph and return to its start, learning the incident edges at each vertex it visits. On $n$-vertex graphs, the best known competitive ratio has been $O(\log n)$, achieved by several algorithms, among them the hierarchical depth-first search of Megow, Mehlhorn, and Schweitzer. We give an algorithm with competitive ratio ${(2+o(1))}\ln n/\ln\ln n$ for known~$n$. Like hierarchical depth-first search, it groups the edges into geometric weight classes and searches depth-first between components of lighter edges. Unlike it, the agent tours each component along a minimum spanning tree for the original weights, so only crossings between components pay for rounding, and the base $b$ of the weight class can grow with~$n$. The leading constant $2$ is tight for our choice of base. Without knowing $n$, restarts with increasing size guesses give upper bounds with leading constant $4$ for a fixed schedule and $2$ in expectation for a randomly shifted schedule. If the weights lie in a known range $[1,2^k]$ with $k\ge4$, choosing $b=k/\log_2 k$ gives a competitive ratio of $O(k/\log k)$ without knowing $n$.

Authors: Max Klimm

In online graph exploration, an agent must visit every vertex of an unknown weighted graph and return to its start, learning the incident edges at each vertex it visits. On $n$-vertex graphs, the best known competitive ratio has been $O(\log n)$, achieved by several algorithms, among them the hierarchical depth-first search of Megow, Mehlhorn, and Schweitzer. We give an algorithm with competitive ratio ${(2+o(1))}\ln n/\ln\ln n$ for known~$n$. Like hierarchical depth-first search, it groups the edges into geometric weight classes and searches depth-first between components of lighter edges. Unlike it, the agent tours each component along a minimum spanning tree for the original weights, so only crossings between components pay for rounding, and the base $b$ of the weight class can grow with~$n$. The leading constant $2$ is tight for our choice of base. Without knowing $n$, restarts with increasing size guesses give upper bounds with leading constant $4$ for a fixed schedule and $2$ in expectation for a randomly shifted schedule. If the weights lie in a known range $[1,2^k]$ with $k\ge4$, choosing $b=k/\log_2 k$ gives a competitive ratio of $O(k/\log k)$ without knowing $n$.

Multiple-Choice Secretary Problem with Predictions

from arXiv: Data Structures and Algorithms

Authors: Jing Yuan, Qi Cai, Xin Gao, Shaojie Tang

We study the multiple-choice secretary problem, in which candidates arrive in uniformly random order and the goal is to select at most $k$ candidates to maximize their total value. We consider a setting where predictions of individual candidate values are available before any candidate arrives. Fujii and Yoshida's Learned Kleinberg algorithm achieves competitive loss $O(\min\{\log k/\sqrt{k},\eps\})$, where $k$ is the selection capacity and $\eps$ is the maximum multiplicative prediction error. We remove the logarithmic factor through a sharper analysis of the same switching algorithm with a retuned threshold. The resulting competitive ratio is at least $\max\{0,1-\min\{32/\sqrt{k},4\eps\}\}$. In particular, exact predictions ($\eps=0$) achieve the offline optimum on every arrival order.

Authors: Jing Yuan, Qi Cai, Xin Gao, Shaojie Tang

We study the multiple-choice secretary problem, in which candidates arrive in uniformly random order and the goal is to select at most $k$ candidates to maximize their total value. We consider a setting where predictions of individual candidate values are available before any candidate arrives. Fujii and Yoshida's Learned Kleinberg algorithm achieves competitive loss $O(\min\{\log k/\sqrt{k},\eps\})$, where $k$ is the selection capacity and $\eps$ is the maximum multiplicative prediction error. We remove the logarithmic factor through a sharper analysis of the same switching algorithm with a retuned threshold. The resulting competitive ratio is at least $\max\{0,1-\min\{32/\sqrt{k},4\eps\}\}$. In particular, exact predictions ($\eps=0$) achieve the offline optimum on every arrival order.

Wednesday, November 11

Fall Jobs Post 2026

from Computational Complexity

Each fall I try to predict the upcoming job market for theoretical computer science faculty and give suggestions to those pursuing these positions. Last year I wrote that we should get set for a rocky ride, with AI’s disruption of computer science, fiscal stress at universities, and new U.S. policies affecting visas and funding.

Rocky indeed. The job market for computer science graduates continues to decline and with it undergraduate enrollment in the discipline. That should crater demand for CS professors, but anecdotally I'm seeing quite a few departments advertising multiple slots. Perhaps as more computer science departments create Artificial Intelligence programs, deans see the need for continued growth in computing.

Mostly though we're seeing hiring at schools with reasonably good finances, those with large endowments and state flagship universities. Many other schools are struggling and having hiring cutbacks or outright freezes. So I expect the strongest theory students will still find good positions but the second tier might be more challenging than in the past. Oddly enough, a candidate may have an easier time landing a job at a top university than at a mid-tier one.

I'm pessimistic that the recent elections will change much, at least for the next couple of years. Democrats won't make higher education a priority issue. At best they will slow the development of AI but it will continue to disrupt not just computer science but all of higher ed. Trump will remain president for two more years so I don't expect we'll see major changes in visa policy, at least not in a positive direction. Other causes of financial stress, including Baumol's cost disease, the tough job market for new computer science graduates, the public perception of higher education, and the demographic cliff will not go away. Perhaps universities will learn how to use artificial intelligence to cut costs but I'm not holding my breath.

On the positive side, Congress could use the appropriations process to reopen the NSF spigot, though that could take years to play out.

On to specific advice for students on the academic job market. 

CATCS maintains a Theoretical Computer Science Jobs posting site. More generally in computer science, there is the CRA Database of Job Candidates and the CRA and ACM job postings. 

Don't shy away from artificial intelligence. Make sure you talk about AI in both your research and teaching statements. Departments will need instructors who can teach the courses in all the new AI majors popping up.

Have a well-designed website with all your job materials and links to your papers (AI can help). Make sure your Google Scholar, LinkedIn and GitHub (if relevant) sites are accurate and up to date. Make a short video describing your research to a general computer science crowd. Take advantage of all the links above. Reach out directly to professors you know at schools you are interested in. And start now.

By Lance Fortnow

Each fall I try to predict the upcoming job market for theoretical computer science faculty and give suggestions to those pursuing these positions. Last year I wrote that we should get set for a rocky ride, with AI’s disruption of computer science, fiscal stress at universities, and new U.S. policies affecting visas and funding.

Rocky indeed. The job market for computer science graduates continues to decline and with it undergraduate enrollment in the discipline. That should crater demand for CS professors, but anecdotally I'm seeing quite a few departments advertising multiple slots. Perhaps as more computer science departments create Artificial Intelligence programs, deans see the need for continued growth in computing.

Mostly though we're seeing hiring at schools with reasonably good finances, those with large endowments and state flagship universities. Many other schools are struggling and having hiring cutbacks or outright freezes. So I expect the strongest theory students will still find good positions but the second tier might be more challenging than in the past. Oddly enough, a candidate may have an easier time landing a job at a top university than at a mid-tier one.

I'm pessimistic that the recent elections will change much, at least for the next couple of years. Democrats won't make higher education a priority issue. At best they will slow the development of AI but it will continue to disrupt not just computer science but all of higher ed. Trump will remain president for two more years so I don't expect we'll see major changes in visa policy, at least not in a positive direction. Other causes of financial stress, including Baumol's cost disease, the tough job market for new computer science graduates, the public perception of higher education, and the demographic cliff will not go away. Perhaps universities will learn how to use artificial intelligence to cut costs but I'm not holding my breath.

On the positive side, Congress could use the appropriations process to reopen the NSF spigot, though that could take years to play out.

On to specific advice for students on the academic job market. 

CATCS maintains a Theoretical Computer Science Jobs posting site. More generally in computer science, there is the CRA Database of Job Candidates and the CRA and ACM job postings. 

Don't shy away from artificial intelligence. Make sure you talk about AI in both your research and teaching statements. Departments will need instructors who can teach the courses in all the new AI majors popping up.

Have a well-designed website with all your job materials and links to your papers (AI can help). Make sure your Google Scholar, LinkedIn and GitHub (if relevant) sites are accurate and up to date. Make a short video describing your research to a general computer science crowd. Take advantage of all the links above. Reach out directly to professors you know at schools you are interested in. And start now.

By Lance Fortnow

TR26-317 | Explicit Subspace Evasive Sets via Subspace Designs | Yeyuan Chen, Joshua Brakensiek, Rohan Goyal, Venkatesan Guruswami, Mahdi Cheraghchi, Aaron (Louie) Putterman, Zihan Zhang

from ECCC Papers

Given a finite field $\mathbb F_q$, we say that a set $A\subseteq \mathbb F^n_q$ is an $(r,c)$ subspace evasive set if and only if for any affine subspace $U\subseteq \mathbb F^n_q$ with bounded dimension $\dim(U)\leq r$, the intersection size $|A\cap U|$ is at most $c$. The probabilistic method shows the existence of $(r,c)$ subspace evasive sets with $|A| = q^{(1-\epsilon) n}$ with $c = O(r/\epsilon)$. However, the best explicit constructions by Dvir--Lovett (STOC 2012) and Ben-Aroya--Shinkar (CJTCS 2013) have $c$ growing as an exponential function of $r$. Here, we give an explicit construction of such subspace evasive set that achieves the intersection bound $c=O(\min(r\log(r/\epsilon)/\epsilon, r^2/\epsilon))$ when both $r$ and $1/\epsilon$ are constants. Our approach is simple and the key idea is to compose subspace design codes (Guruswami-Xing, STOC 2013) with a suitably chosen ``local'' subspace evasive set. As a corollary, we give the first construction of an explicit (strongly) capacity-achieving list-recoverable code with nearly optimal list size, circumventing all previously-known barriers to construction.
Given a finite field $\mathbb F_q$, we say that a set $A\subseteq \mathbb F^n_q$ is an $(r,c)$ subspace evasive set if and only if for any affine subspace $U\subseteq \mathbb F^n_q$ with bounded dimension $\dim(U)\leq r$, the intersection size $|A\cap U|$ is at most $c$. The probabilistic method shows the existence of $(r,c)$ subspace evasive sets with $|A| = q^{(1-\epsilon) n}$ with $c = O(r/\epsilon)$. However, the best explicit constructions by Dvir--Lovett (STOC 2012) and Ben-Aroya--Shinkar (CJTCS 2013) have $c$ growing as an exponential function of $r$. Here, we give an explicit construction of such subspace evasive set that achieves the intersection bound $c=O(\min(r\log(r/\epsilon)/\epsilon, r^2/\epsilon))$ when both $r$ and $1/\epsilon$ are constants. Our approach is simple and the key idea is to compose subspace design codes (Guruswami-Xing, STOC 2013) with a suitably chosen ``local'' subspace evasive set. As a corollary, we give the first construction of an explicit (strongly) capacity-achieving list-recoverable code with nearly optimal list size, circumventing all previously-known barriers to construction.

Solomonoff Induction with Reflective Oracles

from arXiv: Computational Complexity

Authors: Damini Kusum

We study predictive properties of a reflective variant of Solomonoff induction formulated using reflective oracles (Fallenstein et al. 2015, Wyeth et al. 2025). We show that the resulting optimal predictor succeeds against computable predictive strategies that specify only part of the data-generating process. The argument relies on the fact that hypotheses computable from the predictor's own conditional probabilities remain within the reflective hypothesis class. In particular, the predictor learns incomplete models specified by computable interval restrictions on next-bit probabilities. We also establish weighted forms of unbiasedness and calibration. Finally, we discuss whether an optimal predictor's conditional probabilities suffice to compute every hypothesis in the reflective class.

Authors: Damini Kusum

We study predictive properties of a reflective variant of Solomonoff induction formulated using reflective oracles (Fallenstein et al. 2015, Wyeth et al. 2025). We show that the resulting optimal predictor succeeds against computable predictive strategies that specify only part of the data-generating process. The argument relies on the fact that hypotheses computable from the predictor's own conditional probabilities remain within the reflective hypothesis class. In particular, the predictor learns incomplete models specified by computable interval restrictions on next-bit probabilities. We also establish weighted forms of unbiasedness and calibration. Finally, we discuss whether an optimal predictor's conditional probabilities suffice to compute every hypothesis in the reflective class.

Uniform Quantum Average-Case Fine-Grained Hardness of Arithmetized $k$-Orthogonal Vectors

from arXiv: Computational Complexity

Authors: Dhruv Prasad Deshpande, Abhishek Mishra

We study exact evaluation of the arithmetized $k$-Orthogonal Vectors polynomial $FOV^k$ of Ball et al. (2017, 2018). For every fixed integer $k \geq 3$, set $d(n) = \left \lceil \log^2 n \right \rceil$. Assuming the basic decision version of Quantum Strong Exponential-Time Hypothesis (QSETH), for every constant $\varepsilon > 0$, no uniform quantum algorithm runs in $O(n^{k/2 - \varepsilon})$ time on every input and evaluates this polynomial correctly with probability at least $3 / 4$ over a uniformly random input in $\mathbb F_{p(n)}^{knd(n)}$ and the algorithm's internal randomness, for all sufficiently large $n$. This holds when $p(n)$ is the smallest prime greater than $n^{k - 1}$ and when it is the smallest prime greater than $n^k$. Our direct reduction combines classical polynomial self-correction with calls to a quantum average-case evaluator. For the smaller prime, random sampling finds an orthogonal tuple with constant probability whenever the count is large enough to wrap around modulo $p(n)$; otherwise, the exact residue determines the answer. For the larger prime, quantum minimum finding and an asymptotic prime-gap bound account for the cost of generating the prescribed field. In view of prior isolation-based reductions permitting small characteristics, we present these results as explicit reductions for the two canonical-prime families, with all setup costs included in the uniform quantum running time. The hardness guarantee concerns single-instance exact evaluation; a matching quantum evaluation algorithm and a quantum proof-of-work protocol remain open.

Authors: Dhruv Prasad Deshpande, Abhishek Mishra

We study exact evaluation of the arithmetized $k$-Orthogonal Vectors polynomial $FOV^k$ of Ball et al. (2017, 2018). For every fixed integer $k \geq 3$, set $d(n) = \left \lceil \log^2 n \right \rceil$. Assuming the basic decision version of Quantum Strong Exponential-Time Hypothesis (QSETH), for every constant $\varepsilon > 0$, no uniform quantum algorithm runs in $O(n^{k/2 - \varepsilon})$ time on every input and evaluates this polynomial correctly with probability at least $3 / 4$ over a uniformly random input in $\mathbb F_{p(n)}^{knd(n)}$ and the algorithm's internal randomness, for all sufficiently large $n$. This holds when $p(n)$ is the smallest prime greater than $n^{k - 1}$ and when it is the smallest prime greater than $n^k$. Our direct reduction combines classical polynomial self-correction with calls to a quantum average-case evaluator. For the smaller prime, random sampling finds an orthogonal tuple with constant probability whenever the count is large enough to wrap around modulo $p(n)$; otherwise, the exact residue determines the answer. For the larger prime, quantum minimum finding and an asymptotic prime-gap bound account for the cost of generating the prescribed field. In view of prior isolation-based reductions permitting small characteristics, we present these results as explicit reductions for the two canonical-prime families, with all setup costs included in the uniform quantum running time. The hardness guarantee concerns single-instance exact evaluation; a matching quantum evaluation algorithm and a quantum proof-of-work protocol remain open.

Complexity of Deciding Existence of Maltsev Polymorphisms of Finite Relational Structures

from arXiv: Computational Complexity

Authors: Dejan Delic, Ali Syed

In this article, we show that the problem of deciding whether a finite relational structure $\mathbf{A}$ admits a Maltsev polymorphism is a computational problem, which can be solved in polynomial time. We provide a proof of this result by reducing the problem to deciding whether a binary relational structure, associated with $\mathbf{A}$ admits such a polymorphism. In our construction of such an algorithm, we make an extensive use of a property of binary relations, which is implied by the existence of a Maltsev polymorphism, the so-called rectangularity property.

Authors: Dejan Delic, Ali Syed

In this article, we show that the problem of deciding whether a finite relational structure $\mathbf{A}$ admits a Maltsev polymorphism is a computational problem, which can be solved in polynomial time. We provide a proof of this result by reducing the problem to deciding whether a binary relational structure, associated with $\mathbf{A}$ admits such a polymorphism. In our construction of such an algorithm, we make an extensive use of a property of binary relations, which is implied by the existence of a Maltsev polymorphism, the so-called rectangularity property.

$\mathsf{SVP}_\infty$ Is NP-Hard for Power-of-two Cyclotomic Ideals

from arXiv: Computational Complexity

Authors: Yansong Feng, Jiaqi Liu, Hengyi Luo, Yanbin Pan

We prove that exact decision-$\mathsf{SVP}$ in the coefficient $\ell_\infty$-norm is $\mathsf{NP}$-complete for principal ideals and free modules of rank two over the cyclotomic rings $R_n=\mathbb{Z}[X]/(X^n+1)$, where $n$ ranges over powers of two. For each case, we give a deterministic polynomial-time many-one reduction from the Subset Sum problem. For an instance with $s$ positive input integers, the output lattice has dimension $O(s)$. A solution to the original Subset Sum instance can be recovered in polynomial time from any nonzero output lattice vector of norm at most the specified bound. We also transfer these reductions from $R_n$ to the power-of-two cyclic rings $S_{2n}=\mathbb{Z}[X]/(X^{2n}-1)$. This gives $\mathsf{NP}$-completeness of decision-$\mathsf{SVP}$ in the coefficient $\ell_\infty$-norm for principal ideals and free modules of any fixed positive rank over these rings.

Authors: Yansong Feng, Jiaqi Liu, Hengyi Luo, Yanbin Pan

We prove that exact decision-$\mathsf{SVP}$ in the coefficient $\ell_\infty$-norm is $\mathsf{NP}$-complete for principal ideals and free modules of rank two over the cyclotomic rings $R_n=\mathbb{Z}[X]/(X^n+1)$, where $n$ ranges over powers of two. For each case, we give a deterministic polynomial-time many-one reduction from the Subset Sum problem. For an instance with $s$ positive input integers, the output lattice has dimension $O(s)$. A solution to the original Subset Sum instance can be recovered in polynomial time from any nonzero output lattice vector of norm at most the specified bound. We also transfer these reductions from $R_n$ to the power-of-two cyclic rings $S_{2n}=\mathbb{Z}[X]/(X^{2n}-1)$. This gives $\mathsf{NP}$-completeness of decision-$\mathsf{SVP}$ in the coefficient $\ell_\infty$-norm for principal ideals and free modules of any fixed positive rank over these rings.

From Worst-Case to Smoothed Complexity in Continuous Optimization

from arXiv: Computational Complexity

Authors: Daniel Cortild, Coralia Cartis

Worst-case complexity bounds often fail to reflect the practical performance of optimization algorithms, while average-case complexity heavily relies on the distribution of the input. In this work, we develop a smoothed-analysis framework for classical continuous optimization algorithms by studying their behaviour on random perturbations of arbitrary functions. Our main contribution is to apply methods suited for non-degenerate functions to perturbations of degenerate functions, thereby recovering the faster best-known rates for the non-degenerate class. We derive smoothed complexity guarantees for several standard methods, including (Accelerated) Gradient Descent, Conjugate Gradient, and Newton-type methods, under various settings including nonconvex ones, and show that these bounds can substantially improve upon their worst-case guarantees, bringing them closer to the practical behaviour of the respective methods.

Authors: Daniel Cortild, Coralia Cartis

Worst-case complexity bounds often fail to reflect the practical performance of optimization algorithms, while average-case complexity heavily relies on the distribution of the input. In this work, we develop a smoothed-analysis framework for classical continuous optimization algorithms by studying their behaviour on random perturbations of arbitrary functions. Our main contribution is to apply methods suited for non-degenerate functions to perturbations of degenerate functions, thereby recovering the faster best-known rates for the non-degenerate class. We derive smoothed complexity guarantees for several standard methods, including (Accelerated) Gradient Descent, Conjugate Gradient, and Newton-type methods, under various settings including nonconvex ones, and show that these bounds can substantially improve upon their worst-case guarantees, bringing them closer to the practical behaviour of the respective methods.

The Monophonic Directed Convexities

from arXiv: Computational Complexity

Authors: Júlio Araújo, Ana Karolinna Maia, Thiago Marcilon, Nicolas Nisse, Rudini M. Sampaio

Graph Convexity is a topic with many papers in the literature, especially on the $P_3$, geodesic, and monophonic convexities in undirected graphs. Regarding directed graphs, Erd{\H o}s et al. in 1972 and Chartrand and Zhang in 2000 obtained the first results on the $P_3$ and geodesic convexities for directed graphs, respectively. In this paper, we start the investigation of monophonic convexity on directed graphs. We define two convexities, the monophonic and the strong monophonic directed convexities, related to the minimal and the induced directed paths, respectively. We show that deciding whether a set is convex is polynomial-time solvable in the monophonic convexity, but coNP-complete in the strong monophonic convexity. For both convexities, we prove that the hull number is NP-complete even in DAGs. Regarding the monophonic convexity, we prove that the hull number is polynomial time solvable in tournaments, but the interval number is NP-complete in tournaments and also in bipartite oriented graphs.

Authors: Júlio Araújo, Ana Karolinna Maia, Thiago Marcilon, Nicolas Nisse, Rudini M. Sampaio

Graph Convexity is a topic with many papers in the literature, especially on the $P_3$, geodesic, and monophonic convexities in undirected graphs. Regarding directed graphs, Erd{\H o}s et al. in 1972 and Chartrand and Zhang in 2000 obtained the first results on the $P_3$ and geodesic convexities for directed graphs, respectively. In this paper, we start the investigation of monophonic convexity on directed graphs. We define two convexities, the monophonic and the strong monophonic directed convexities, related to the minimal and the induced directed paths, respectively. We show that deciding whether a set is convex is polynomial-time solvable in the monophonic convexity, but coNP-complete in the strong monophonic convexity. For both convexities, we prove that the hull number is NP-complete even in DAGs. Regarding the monophonic convexity, we prove that the hull number is polynomial time solvable in tournaments, but the interval number is NP-complete in tournaments and also in bipartite oriented graphs.

Feedback Vertex Set, Max Cut, and Edge Coloring on the Strong Product of a Graph and a Path

from arXiv: Computational Complexity

Authors: Jan Diester, Kolja Kühn, Manuel Rapp, Samuel Schneider, Torsten Ueckerdt

We examine the computational complexity of well-known problems on subgraphs of the strong product of two paths. Namely, for Max Cut we show NP-hardness on induced subgraphs of $P \boxtimes P$ answering a question by Dvořák, Huynh, Joret, Liu, and Wood (2021). For 3-Edge Coloring we show NP-hardness on subgraphs of $P \boxtimes P$ and that it is equivalent to 3-Edge Coloring on planar graphs for induced subgraphs of $P \boxtimes P$. It is a long standing open question whether 3-Edge Coloring on planar graphs is NP-hard. As a second contribution, we consider graphs of the form $G \boxtimes P$ and show that Feedback Vertex Set on these graphs is FPT in the clique-width of $G$. Furthermore, we show that it can be solved in polynomial time if $G$ is chordal or co-comparable and that the computational complexity depends on the parity of $P$ if $G$ is bipartite. Namely, it is solvable in polynomial time if $P$ has an even number of vertices but is NP-complete otherwise. For Max Cut, we show that it can be solved in polynomial time if $G$ is bipartite.

Authors: Jan Diester, Kolja Kühn, Manuel Rapp, Samuel Schneider, Torsten Ueckerdt

We examine the computational complexity of well-known problems on subgraphs of the strong product of two paths. Namely, for Max Cut we show NP-hardness on induced subgraphs of $P \boxtimes P$ answering a question by Dvořák, Huynh, Joret, Liu, and Wood (2021). For 3-Edge Coloring we show NP-hardness on subgraphs of $P \boxtimes P$ and that it is equivalent to 3-Edge Coloring on planar graphs for induced subgraphs of $P \boxtimes P$. It is a long standing open question whether 3-Edge Coloring on planar graphs is NP-hard. As a second contribution, we consider graphs of the form $G \boxtimes P$ and show that Feedback Vertex Set on these graphs is FPT in the clique-width of $G$. Furthermore, we show that it can be solved in polynomial time if $G$ is chordal or co-comparable and that the computational complexity depends on the parity of $P$ if $G$ is bipartite. Namely, it is solvable in polynomial time if $P$ has an even number of vertices but is NP-complete otherwise. For Max Cut, we show that it can be solved in polynomial time if $G$ is bipartite.

Local Modifications of Nearest-Neighbor and Min-Plus Representations

from arXiv: Computational Complexity

Authors: Liliia Redina

We study how changing a Boolean-valued function at $d$ inputs affects the size and precision of its exact representations. Starting from a representation of size $m$, we prove four bounds, two for nearest-neighbor (NN) representations and two for integer min-plus representations. (i) For NN representations on a finite subset of $\mathbb{R}^n$ with $n\ge2$, at most $m+2d$ anchors suffice. The coefficient $2$ is optimal: on a three-point domain, changing one value can increase the minimum number of anchors from one to three. (ii) For NN representations on the Boolean cube with rational anchors, let $R$ be the maximum original coordinate bit length, and let $Δ$ be the maximum bit length of the least common denominator of any one original anchor's coordinates. We construct a representation with at most $m+3d$ anchors on a common dyadic grid and coordinate bit length $O(R+Δ+\log(n+1))$. (iii) For integer min-plus representations on the Boolean cube, we give a construction that keeps the original $m$ forms and their labels and adds at most $d$ new forms. Its maximum weight is at most $W+2n$, where $W$ is the largest absolute original coefficient, including constant terms. (iv) For integer min-plus representations on a finite rational domain $X\subset\mathbb{Q}^n$, at most $m+2d$ forms suffice. Their maximum weight is polynomially bounded in $m,d,W,n,|X|$, the coordinate bound, and the common denominator of $X$. The coefficient $2$ is again optimal: on a three-point domain, changing one value can increase the minimum number of forms from one to three. These bounds imply stability under polynomially many changes on the cube for polynomial-size representations, including those with polynomially bounded NN coordinate bit length or min-plus weight.

Authors: Liliia Redina

We study how changing a Boolean-valued function at $d$ inputs affects the size and precision of its exact representations. Starting from a representation of size $m$, we prove four bounds, two for nearest-neighbor (NN) representations and two for integer min-plus representations. (i) For NN representations on a finite subset of $\mathbb{R}^n$ with $n\ge2$, at most $m+2d$ anchors suffice. The coefficient $2$ is optimal: on a three-point domain, changing one value can increase the minimum number of anchors from one to three. (ii) For NN representations on the Boolean cube with rational anchors, let $R$ be the maximum original coordinate bit length, and let $Δ$ be the maximum bit length of the least common denominator of any one original anchor's coordinates. We construct a representation with at most $m+3d$ anchors on a common dyadic grid and coordinate bit length $O(R+Δ+\log(n+1))$. (iii) For integer min-plus representations on the Boolean cube, we give a construction that keeps the original $m$ forms and their labels and adds at most $d$ new forms. Its maximum weight is at most $W+2n$, where $W$ is the largest absolute original coefficient, including constant terms. (iv) For integer min-plus representations on a finite rational domain $X\subset\mathbb{Q}^n$, at most $m+2d$ forms suffice. Their maximum weight is polynomially bounded in $m,d,W,n,|X|$, the coordinate bound, and the common denominator of $X$. The coefficient $2$ is again optimal: on a three-point domain, changing one value can increase the minimum number of forms from one to three. These bounds imply stability under polynomially many changes on the cube for polynomial-size representations, including those with polynomially bounded NN coordinate bit length or min-plus weight.

Computational Power of Clifford and Ising Quantum Computers

from arXiv: Computational Complexity

Authors: Sawyer Dobson, Zhenghan Wang

We extend the efficient classical simulation of Ising quantum computers from braidings to measurements. We investigate several different definitions of efficient Clifford quantum computation by varying the power of the circuit generator. In case the circuit generator can see the entire input, we give a detailed proof that efficient simulation of classical computation would imply the separation of complexity classes $\mathbf{P}$ and $\mathbf{PSPACE}$. If the circuit generator sees only the input length, we prove that Clifford quantum computers decide what we call affine languages.

Authors: Sawyer Dobson, Zhenghan Wang

We extend the efficient classical simulation of Ising quantum computers from braidings to measurements. We investigate several different definitions of efficient Clifford quantum computation by varying the power of the circuit generator. In case the circuit generator can see the entire input, we give a detailed proof that efficient simulation of classical computation would imply the separation of complexity classes $\mathbf{P}$ and $\mathbf{PSPACE}$. If the circuit generator sees only the input length, we prove that Clifford quantum computers decide what we call affine languages.

Constant query LCCs over the reals

from arXiv: Computational Complexity

Authors: Zeev Dvir

This note describes a new construction, found by ChatGPT Astra, of constant query Locally Correctable Codes (LCCs) over the real numbers. Prior constructions of constant query LCCs were exclusive to fields of positive characteristic and were conjectured not to exist over the reals. The construction uses low degree polynomial evaluations over an integer grid, together with a novel sampling procedure which outputs, for a given grid point $P$, a random quadratic curve through $P$ which intersects the grid in many other points (the decoding queries). The sampler is `smooth' in the sense that no grid point is queried with high probability. These codes have the additional property that the queried locations (the curve/grid intersections) are all nearby grid points.

Authors: Zeev Dvir

This note describes a new construction, found by ChatGPT Astra, of constant query Locally Correctable Codes (LCCs) over the real numbers. Prior constructions of constant query LCCs were exclusive to fields of positive characteristic and were conjectured not to exist over the reals. The construction uses low degree polynomial evaluations over an integer grid, together with a novel sampling procedure which outputs, for a given grid point $P$, a random quadratic curve through $P$ which intersects the grid in many other points (the decoding queries). The sampler is `smooth' in the sense that no grid point is queried with high probability. These codes have the additional property that the queried locations (the curve/grid intersections) are all nearby grid points.

Linear-size graphs at every strict dismantling level

from arXiv: Computational Geometry

Authors: Jesús F. Espinoza, Martín Eduardo Frías-Armenta, Rosalía G. Hernández-Amador, Héctor A. Hernández-Hernández

Dismantling reduces a graph to one vertex by successive deletions. At level zero, a vertex is eligible if one of its neighbours is adjacent to all its other neighbours. At level $k\geq1$, its neighbours must induce a graph dismantlable at level $k-1$. A graph has strict level $k$ if it admits a reduction at level $k$ and none at level $k-1$. For every $k\geq1$, we construct a graph of strict level $k$ with $3k+8$ vertices. Each step adds three vertices: the neighbours of one induce the preceding graph, and the other two provide the adjacencies used to rule out other first deletions at the lower level. A second construction gives a graph of order $4k+4$ at strict level $k$. Together the two families give the upper bound $\min\{4k+4,3k+8\}$ on the least order at strict level $k$.

Authors: Jesús F. Espinoza, Martín Eduardo Frías-Armenta, Rosalía G. Hernández-Amador, Héctor A. Hernández-Hernández

Dismantling reduces a graph to one vertex by successive deletions. At level zero, a vertex is eligible if one of its neighbours is adjacent to all its other neighbours. At level $k\geq1$, its neighbours must induce a graph dismantlable at level $k-1$. A graph has strict level $k$ if it admits a reduction at level $k$ and none at level $k-1$. For every $k\geq1$, we construct a graph of strict level $k$ with $3k+8$ vertices. Each step adds three vertices: the neighbours of one induce the preceding graph, and the other two provide the adjacencies used to rule out other first deletions at the lower level. A second construction gives a graph of order $4k+4$ at strict level $k$. Together the two families give the upper bound $\min\{4k+4,3k+8\}$ on the least order at strict level $k$.

Unilluminable rooms: minimal examples, classifications and exceptions

from arXiv: Computational Geometry

Authors: J. C. F. de Winter, George W. Tokarsky

A room with mirrored walls can contain two points that are mutually invisible: no light ray from one reaches the other. Tokarsky built the first polygonal examples by tiling a room with reflected copies of a triangle and making every tile vertex of certain kinds a corner of the room. We study the smallest rooms of this kind, which we call lattice rooms. Their interior tile vertices of the remaining kind, the sources, are invisible and pairwise mutually invisible. On the tiling by isosceles right triangles, a hole-free lattice room with a source has at least 12 sides, attained only by the pinwheel. On the square tiling the least number is 16, again attained by one room. A hole-free lattice room with two sources has at least 24 sides on the first tiling and 34 on the square tiling. Up to congruence there are 12 such rooms with 24 sides, 89 with 25 sides and 14 with 34 sides. One absorbing post, one partition, or one hole that touches the outer boundary at one point lowers the least number of sides for two sources to 18, 20 and 22 (21 if sides are counted as maximal straight segments). Two and three posts give 17 and 16 sides, and a hole that does not touch the outer boundary gives 26. We list all smallest rooms. Rooms assembled from n modules have exactly 12n sides and n sources, and a hole-free lattice room with three or more sources has at least 36 sides. We also give rooms in which some tile vertices need not be corners: 15 types of 27-sided rooms on the tiling by triangles with angles 30, 60 and 90 degrees, which are smallest in their class, a nonagon with three mutually invisible corners, and a 42-sided room in which a rotation through 180 degrees takes the place of a corner. In a ring of three trapezoids a light ray returns to a corner that is invisible in one trapezoid. Several classifications rely on exhaustive computer searches made finite by the bounds proved here.

Authors: J. C. F. de Winter, George W. Tokarsky

A room with mirrored walls can contain two points that are mutually invisible: no light ray from one reaches the other. Tokarsky built the first polygonal examples by tiling a room with reflected copies of a triangle and making every tile vertex of certain kinds a corner of the room. We study the smallest rooms of this kind, which we call lattice rooms. Their interior tile vertices of the remaining kind, the sources, are invisible and pairwise mutually invisible. On the tiling by isosceles right triangles, a hole-free lattice room with a source has at least 12 sides, attained only by the pinwheel. On the square tiling the least number is 16, again attained by one room. A hole-free lattice room with two sources has at least 24 sides on the first tiling and 34 on the square tiling. Up to congruence there are 12 such rooms with 24 sides, 89 with 25 sides and 14 with 34 sides. One absorbing post, one partition, or one hole that touches the outer boundary at one point lowers the least number of sides for two sources to 18, 20 and 22 (21 if sides are counted as maximal straight segments). Two and three posts give 17 and 16 sides, and a hole that does not touch the outer boundary gives 26. We list all smallest rooms. Rooms assembled from n modules have exactly 12n sides and n sources, and a hole-free lattice room with three or more sources has at least 36 sides. We also give rooms in which some tile vertices need not be corners: 15 types of 27-sided rooms on the tiling by triangles with angles 30, 60 and 90 degrees, which are smallest in their class, a nonagon with three mutually invisible corners, and a 42-sided room in which a rotation through 180 degrees takes the place of a corner. In a ring of three trapezoids a light ray returns to a corner that is invisible in one trapezoid. Several classifications rely on exhaustive computer searches made finite by the bounds proved here.

Parameterized Complexity and Geometric Approximation of Riesz Energy Subset Selection

from arXiv: Data Structures and Algorithms

Authors: Michael Emmerich, Soumen Atta

We choose $k$ of $n$ sites to minimize Riesz $s$-energy, in which a pair at distance $t$ contributes $t^{-s}$. For $s=2$, exact selection is polynomial on a line but NP-hard in the plane. Adapting the proxy lemma of Ceccarello et al. gives an efficient parameterized approximation scheme (EPAS) for fixed Euclidean dimension and fixed $s>0$. To sharpen the bound, we start with a geometric packing. Farthest-first traversal gives $2k$ centers separated by at least the last insertion distance $r$. If one site of an optimum is removed, each of the $k-1$ remaining sites excludes at most one center closer than $r/2$, leaving at least $k+1$ centers free. The new step is a discrete exchange bound: the removed site's interaction energy is at most the average it would contribute at those free centers. In the plane at $s=2$, this reduces the representative bound from $O(k^2\log(2k)/\varepsilon^2)$ for a packing estimate of total energy to $O(k\log(2k)/\varepsilon^2)$, independently of $n$. Rational planar examples show that the resulting separation scale $r/\sqrt{\log(2k)}$ is sharp. A $(1+\varepsilon)$ approximation on rational planar sites takes $O(nk+n\log n)+(C\log(2k)/\varepsilon^2)^k$ operations of polynomial bit cost. The observed number $M$ of representatives determines the search size $\binom{M}{k}$. With one million sites, $k=5$ and $\varepsilon=1/2$, the exchange grid left 252 subsets on clustered inputs and about $9.3\times10^{26}$ on uniform inputs. The method extends to metrics of bounded doubling dimension and to compact domains with effective geometric routines, including filled simple polygons. At $s=2$, exact decision on metrics with nonzero distances in $\{1,2\}$ is W[1]-complete in $k$. A gap that shrinks with $k$ rules out a deterministic EPAS on unrestricted metrics unless FPT = W[1].

Authors: Michael Emmerich, Soumen Atta

We choose $k$ of $n$ sites to minimize Riesz $s$-energy, in which a pair at distance $t$ contributes $t^{-s}$. For $s=2$, exact selection is polynomial on a line but NP-hard in the plane. Adapting the proxy lemma of Ceccarello et al. gives an efficient parameterized approximation scheme (EPAS) for fixed Euclidean dimension and fixed $s>0$. To sharpen the bound, we start with a geometric packing. Farthest-first traversal gives $2k$ centers separated by at least the last insertion distance $r$. If one site of an optimum is removed, each of the $k-1$ remaining sites excludes at most one center closer than $r/2$, leaving at least $k+1$ centers free. The new step is a discrete exchange bound: the removed site's interaction energy is at most the average it would contribute at those free centers. In the plane at $s=2$, this reduces the representative bound from $O(k^2\log(2k)/\varepsilon^2)$ for a packing estimate of total energy to $O(k\log(2k)/\varepsilon^2)$, independently of $n$. Rational planar examples show that the resulting separation scale $r/\sqrt{\log(2k)}$ is sharp. A $(1+\varepsilon)$ approximation on rational planar sites takes $O(nk+n\log n)+(C\log(2k)/\varepsilon^2)^k$ operations of polynomial bit cost. The observed number $M$ of representatives determines the search size $\binom{M}{k}$. With one million sites, $k=5$ and $\varepsilon=1/2$, the exchange grid left 252 subsets on clustered inputs and about $9.3\times10^{26}$ on uniform inputs. The method extends to metrics of bounded doubling dimension and to compact domains with effective geometric routines, including filled simple polygons. At $s=2$, exact decision on metrics with nonzero distances in $\{1,2\}$ is W[1]-complete in $k$. A gap that shrinks with $k$ rules out a deterministic EPAS on unrestricted metrics unless FPT = W[1].

Pair-Merge Tokenisation Is Hard to Approximate on Binary Strings and Strongly NP-Hard on Unary Datasets

from arXiv: Data Structures and Algorithms

Authors: Kundan Baliga, Aiden Xie, Aditya Byju

Tokenisers such as Byte-Pair Encoding (BPE) shorten text by repeatedly merging an adjacent pair of symbols into a new one; fewer tokens mean less computation. We ask whether an efficient algorithm can choose $k$ merges that leave a string of length $n$ almost as short as possible; doing nothing is already within a factor $n$. We prove that, unless P = NP, no polynomial-time algorithm comes within a factor $c\,n/\log n$, for some constant $c>0$, already for one binary string and for BPE-style merges that replace every occurrence. The key idea is that $k$ merges form a grammar with $k$ rules: a vertex-cover gap becomes a grammar-size gap, which we amplify with relabelled copies, encode in binary and realise with explicit merges. For merges that may skip occurrences, a simple algorithm achieves $O(n/\log\log n)$, and no Karp reduction can prove hardness beyond order $n/\log n$ unless coNP $\subseteq$ NP/poly. Over a one-letter alphabet, both tokenisation problems left open by Kastreva et al. are strongly NP-complete on datasets with repeated strings.

Authors: Kundan Baliga, Aiden Xie, Aditya Byju

Tokenisers such as Byte-Pair Encoding (BPE) shorten text by repeatedly merging an adjacent pair of symbols into a new one; fewer tokens mean less computation. We ask whether an efficient algorithm can choose $k$ merges that leave a string of length $n$ almost as short as possible; doing nothing is already within a factor $n$. We prove that, unless P = NP, no polynomial-time algorithm comes within a factor $c\,n/\log n$, for some constant $c>0$, already for one binary string and for BPE-style merges that replace every occurrence. The key idea is that $k$ merges form a grammar with $k$ rules: a vertex-cover gap becomes a grammar-size gap, which we amplify with relabelled copies, encode in binary and realise with explicit merges. For merges that may skip occurrences, a simple algorithm achieves $O(n/\log\log n)$, and no Karp reduction can prove hardness beyond order $n/\log n$ unless coNP $\subseteq$ NP/poly. Over a one-letter alphabet, both tokenisation problems left open by Kastreva et al. are strongly NP-complete on datasets with repeated strings.

A Fast Algorithm for Subspace Convolution

from arXiv: Data Structures and Algorithms

Authors: Shlomo A. Perles, Omri Weinstein

A cornerstone result in Boolean lattice theory is the subset-zeta transform, which computes the $f$-weighted subset summation problem $(Z f)(B)=\sum_{A\subseteq B}f(A)$ for all $ B\subseteq[n]$ in $O(N \log N)$ additions instead of the naïve $O(3^n) = O(N^{\log_2 3})$, where $N=2^n$. This paper studies the algebraic analogue of this problem--the subspace summation problem--where subsets are replaced by linear subspaces in $\mathbb{F}_q^n$. Surprisingly, we show that this problem admits a similar $Θ_q(N_q \log N_q)$-time algorithm, where $N_q$ is the number of subspaces. This improves substantially (in both theory and practice) over lattice-based algorithms ([BHK+16, KKW16]), which are known to be optimal for addition-only algorithms over $\mathbb R$. We prove similar runtimes for inversion, rank-constrained sums and span convolution. We describe two main applications: Fast linear algebra on Grassmann graphs: Matrix--vector multiplication for arbitrary distance-invariant kernels on $N$-vertex Grassmann graphs in $O_q(N\log N)$ arithmetic operations, together with fast spectral projections and exact solutions of the corresponding linear systems. Graph coloring of low binary cut-rank graphs: An $n^{2^{r^2/4+O(1)}}$-time algorithm for computing the chromatic number and chromatic polynomial of an $n$-vertex graph, given a rank-decomposition of width $r$. We also give quantitative reductions from satisfiability and monotone constraint problems. Experiments show speedups in measured running time of up to $18$ over the covering-pair algorithm for the zeta transform, $190$ over Poisson summation for rank-constrained sums, and $22$ over the distance-matrix recurrence for Grassmann kernel multiplication. Lean 4 formalizations of the transform identities, arithmetic operation bounds, and graph-coloring constructions accompany the paper [PW26].

Authors: Shlomo A. Perles, Omri Weinstein

A cornerstone result in Boolean lattice theory is the subset-zeta transform, which computes the $f$-weighted subset summation problem $(Z f)(B)=\sum_{A\subseteq B}f(A)$ for all $ B\subseteq[n]$ in $O(N \log N)$ additions instead of the naïve $O(3^n) = O(N^{\log_2 3})$, where $N=2^n$. This paper studies the algebraic analogue of this problem--the subspace summation problem--where subsets are replaced by linear subspaces in $\mathbb{F}_q^n$. Surprisingly, we show that this problem admits a similar $Θ_q(N_q \log N_q)$-time algorithm, where $N_q$ is the number of subspaces. This improves substantially (in both theory and practice) over lattice-based algorithms ([BHK+16, KKW16]), which are known to be optimal for addition-only algorithms over $\mathbb R$. We prove similar runtimes for inversion, rank-constrained sums and span convolution. We describe two main applications: Fast linear algebra on Grassmann graphs: Matrix--vector multiplication for arbitrary distance-invariant kernels on $N$-vertex Grassmann graphs in $O_q(N\log N)$ arithmetic operations, together with fast spectral projections and exact solutions of the corresponding linear systems. Graph coloring of low binary cut-rank graphs: An $n^{2^{r^2/4+O(1)}}$-time algorithm for computing the chromatic number and chromatic polynomial of an $n$-vertex graph, given a rank-decomposition of width $r$. We also give quantitative reductions from satisfiability and monotone constraint problems. Experiments show speedups in measured running time of up to $18$ over the covering-pair algorithm for the zeta transform, $190$ over Poisson summation for rank-constrained sums, and $22$ over the distance-matrix recurrence for Grassmann kernel multiplication. Lean 4 formalizations of the transform identities, arithmetic operation bounds, and graph-coloring constructions accompany the paper [PW26].

Online Graph Coloring: Competitive Ratios Separating Randomized and Deterministic Algorithms

from arXiv: Data Structures and Algorithms

Authors: Ken-ichi Kawarabayashi, Hirotaka Yoneda, Masataka Yoneda

We study online coloring, focusing on the competitive ratio. The best previously known results were (1) a lower bound of $Ω(n / \log^2 n)$ for both deterministic and randomized algorithms by Halldórsson and Szegedy (1994), (2) an upper bound of $O(n / \log n)$ for randomized algorithms by Halldórsson (1997), and (3) an upper bound of $O(n / \log \log n)$ for deterministic algorithms by Kawarabayashi, Yoneda, and Yoneda (2025). In this paper, we improve these results as follows: 1. A new lower bound of $Ω(n / \log n)$ for deterministic algorithms. 2. A new upper bound of $O(n (\log \log n)^2 / \log^2 n)$ for randomized algorithms. 3. A new upper bound of $O(n / (\log \log n)^{2-\varepsilon})$ for deterministic algorithms for every fixed $\varepsilon>0$. For randomized algorithms, we nearly close the gap between the lower and upper bounds; the remaining gap is only $O((\log \log n)^2)$. We establish the asymptotic separation between randomized and deterministic online graph coloring. Against an oblivious adversary, a polynomial-time randomized algorithm achieves a competitive ratio asymptotically smaller than any deterministic algorithm can guarantee, even with unlimited computation.

Authors: Ken-ichi Kawarabayashi, Hirotaka Yoneda, Masataka Yoneda

We study online coloring, focusing on the competitive ratio. The best previously known results were (1) a lower bound of $Ω(n / \log^2 n)$ for both deterministic and randomized algorithms by Halldórsson and Szegedy (1994), (2) an upper bound of $O(n / \log n)$ for randomized algorithms by Halldórsson (1997), and (3) an upper bound of $O(n / \log \log n)$ for deterministic algorithms by Kawarabayashi, Yoneda, and Yoneda (2025). In this paper, we improve these results as follows: 1. A new lower bound of $Ω(n / \log n)$ for deterministic algorithms. 2. A new upper bound of $O(n (\log \log n)^2 / \log^2 n)$ for randomized algorithms. 3. A new upper bound of $O(n / (\log \log n)^{2-\varepsilon})$ for deterministic algorithms for every fixed $\varepsilon>0$. For randomized algorithms, we nearly close the gap between the lower and upper bounds; the remaining gap is only $O((\log \log n)^2)$. We establish the asymptotic separation between randomized and deterministic online graph coloring. Against an oblivious adversary, a polynomial-time randomized algorithm achieves a competitive ratio asymptotically smaller than any deterministic algorithm can guarantee, even with unlimited computation.

A note on the intractability of enumerating the maximal satisfiable subformulas of a Horn expression

from arXiv: Data Structures and Algorithms

Authors: Oscar Defrain, Corentin Jazeron, Kazuhisa Makino

We show that, given a Horn expression and a family of inclusion-wise maximal satisfiable subsets of its clauses, deciding whether there exists another maximal satisfiable subset is NP-complete. As a consequence, unless P=NP, there is no output-polynomial time algorithm enumerating the maximal satisfiable subformulas of a Horn expression.

Authors: Oscar Defrain, Corentin Jazeron, Kazuhisa Makino

We show that, given a Horn expression and a family of inclusion-wise maximal satisfiable subsets of its clauses, deciding whether there exists another maximal satisfiable subset is NP-complete. As a consequence, unless P=NP, there is no output-polynomial time algorithm enumerating the maximal satisfiable subformulas of a Horn expression.

Directed Singular-Value Sparsifiers with $O(n \log n/ε^2)$ Arcs

from arXiv: Data Structures and Algorithms

Authors: Emile Anand

Given an unweighted directed graph, a sparsifier is a nonnegative reweighting of original arcs that preserves every in-degree and out-degree exactly. In this work, we study singular-value sparsifiers, which are generalizations of spectral sparsifiers. Singular-value sparsifiers find a number of applications in theoretical computer science, such as maintaining directed cuts and flows, speeding up directed Laplacian solvers, and sparsifying dense weight matrices in neural networks. Strong singular-value (SV) approximation supports sparse representations of directed random walks with guarantees that remain stable under products, and controls bilinear error in the left and right Schur-complement metrics. We prove that every unweighted directed graph on $n$ vertices admits an $\varepsilon$-SV sparsifier with $O(n\log(2n)/\varepsilon^2)$ arcs, improving the $O(n\log^5 n/\varepsilon^2)$ support bound of Lau, Wang, and Zhou. The sparsifier is a nonnegative reweighting of original arcs and preserves every in-degree and out-degree exactly. We also give a randomized construction with $\tilde{O}(m+n)$ real-arithmetic running time, where $m$ is the input support size, and the output has the same support bound and rational weights of polynomial bit length.

Authors: Emile Anand

Given an unweighted directed graph, a sparsifier is a nonnegative reweighting of original arcs that preserves every in-degree and out-degree exactly. In this work, we study singular-value sparsifiers, which are generalizations of spectral sparsifiers. Singular-value sparsifiers find a number of applications in theoretical computer science, such as maintaining directed cuts and flows, speeding up directed Laplacian solvers, and sparsifying dense weight matrices in neural networks. Strong singular-value (SV) approximation supports sparse representations of directed random walks with guarantees that remain stable under products, and controls bilinear error in the left and right Schur-complement metrics. We prove that every unweighted directed graph on $n$ vertices admits an $\varepsilon$-SV sparsifier with $O(n\log(2n)/\varepsilon^2)$ arcs, improving the $O(n\log^5 n/\varepsilon^2)$ support bound of Lau, Wang, and Zhou. The sparsifier is a nonnegative reweighting of original arcs and preserves every in-degree and out-degree exactly. We also give a randomized construction with $\tilde{O}(m+n)$ real-arithmetic running time, where $m$ is the input support size, and the output has the same support bound and rational weights of polynomial bit length.

Bounding and Approximating Kostka Numbers

from arXiv: Data Structures and Algorithms

Authors: Jonathan Leake, Zirou Zhang

Kostka numbers, the coefficients of Schur polynomials, count semistandard Young tableaux of prescribed shape and weight. We give a deterministic algorithm for approximating Kostka numbers within a simply exponential factor in the number of variables and the size of the partition. Our approach combines Gurvits capacity bounds for log-concave polynomials with an algorithm for approximating the Gurvits capacity of a Schur polynomial. For a Schur polynomial in $n$ variables indexed by $λ$, we show that the logarithm of the capacity associated with any nonzero coefficient can be approximated to additive error $ε$ in time polynomial in $n$, $|λ|$, and $\log(1/ε)$. The analysis establishes an explicit bounded optimization region and efficient approximate first-order oracles, and handles boundary weights through a factorization into smaller Schur polynomials.

Authors: Jonathan Leake, Zirou Zhang

Kostka numbers, the coefficients of Schur polynomials, count semistandard Young tableaux of prescribed shape and weight. We give a deterministic algorithm for approximating Kostka numbers within a simply exponential factor in the number of variables and the size of the partition. Our approach combines Gurvits capacity bounds for log-concave polynomials with an algorithm for approximating the Gurvits capacity of a Schur polynomial. For a Schur polynomial in $n$ variables indexed by $λ$, we show that the logarithm of the capacity associated with any nonzero coefficient can be approximated to additive error $ε$ in time polynomial in $n$, $|λ|$, and $\log(1/ε)$. The analysis establishes an explicit bounded optimization region and efficient approximate first-order oracles, and handles boundary weights through a factorization into smaller Schur polynomials.

Nonadaptive One-Sided Testing of Binary Rank

from arXiv: Data Structures and Algorithms

Authors: Nader H. Bshouty

The binary rank of a binary matrix is the minimum number of disjoint all-one rectangles that partition its one-entries. We study entry-query testing of binary rank at most $d$, with one-sided error and nonadaptive queries. We give a tester using $\tilde O(d^4/ε^2)$ queries, independent of the matrix dimensions and a general lower bound of $\tilde Ω(d^{3/2}/ε)$.

Authors: Nader H. Bshouty

The binary rank of a binary matrix is the minimum number of disjoint all-one rectangles that partition its one-entries. We study entry-query testing of binary rank at most $d$, with one-sided error and nonadaptive queries. We give a tester using $\tilde O(d^4/ε^2)$ queries, independent of the matrix dimensions and a general lower bound of $\tilde Ω(d^{3/2}/ε)$.

Mixed-integer dual network problems are solvable in strongly polynomial time

from arXiv: Data Structures and Algorithms

Authors: Giacomo Zambelli

In this paper we show that mixed-integer linear programming is solvable in strongly polynomial time if the constraint matrix is totally unimodular with at most two nonzero entries in every row. This is done by reducing the problem to an instance of minimization of an $L$-convex function.

Authors: Giacomo Zambelli

In this paper we show that mixed-integer linear programming is solvable in strongly polynomial time if the constraint matrix is totally unimodular with at most two nonzero entries in every row. This is done by reducing the problem to an instance of minimization of an $L$-convex function.

Bounded Weighted Edit Distance with Metric Costs

from arXiv: Data Structures and Algorithms

Authors: Jihan Wang

We give a deterministic $O(n+k^2)$-time algorithm for bounded weighted edit distance when the input costs form an integer metric on the alphabet extended by a gap symbol. Here $n$ is the total input length and $k$ is the given threshold on the distance. If the distance is at most $k$, the algorithm returns it with an optimal alignment. Otherwise, it reports that the distance exceeds $k$. The running time matches the classical unit-cost bound and is independent of the alphabet size and of the largest cost. The algorithm keeps only the farthest-reaching prefix alignment for each cost and each difference between the total gap costs of the aligned prefixes. For real metrics whose nonzero costs are at least one, scaling and upward rounding give a $(1+\varepsilon)$-approximation for the bounded problem in $\widetilde{O}(n+(k/\varepsilon)^2)$ time. If insertions and deletions have integer costs, the running time improves to $\widetilde{O}(n+k^2/\varepsilon)$.

Authors: Jihan Wang

We give a deterministic $O(n+k^2)$-time algorithm for bounded weighted edit distance when the input costs form an integer metric on the alphabet extended by a gap symbol. Here $n$ is the total input length and $k$ is the given threshold on the distance. If the distance is at most $k$, the algorithm returns it with an optimal alignment. Otherwise, it reports that the distance exceeds $k$. The running time matches the classical unit-cost bound and is independent of the alphabet size and of the largest cost. The algorithm keeps only the farthest-reaching prefix alignment for each cost and each difference between the total gap costs of the aligned prefixes. For real metrics whose nonzero costs are at least one, scaling and upward rounding give a $(1+\varepsilon)$-approximation for the bounded problem in $\widetilde{O}(n+(k/\varepsilon)^2)$ time. If insertions and deletions have integer costs, the running time improves to $\widetilde{O}(n+k^2/\varepsilon)$.

What to Predict for Efficient Scheduling on Parallel Machines

from arXiv: Data Structures and Algorithms

Authors: Evripidis Bampis, Bruno Escoffier, Dimitris Fotakis, Giorgos Mitropoulos, Michalis Xefteris

We study learning-augmented algorithms for scheduling on multiple parallel machines under the objectives of minimizing the makespan or the total weighted completion time. We assume that the algorithm has access to noisy information (the prediction) about an optimal solution, expressed through a solution encoding that implicitly quantifies both the amount of information provided and the nature of noise (errors in the prediction). Our central question is to determine the maximum level of noise that still allows for efficiently recovering this optimal solution. We observe that information guiding greedy scheduling to optimality or revealing the optimal assignment of tasks to machines is very sensitive to noise, and prove that recovering an optimal solution from solution encodings capturing either is computationally hard, even for a small (non-constant) number of errors. On the positive side, we show that an order-based encoding, which leads to errors that are dispersed locally, is robust to noise. We present a dynamic programming framework that utilizes this encoding and solves optimally several classical scheduling problems, including makespan and total weighted completion time minimization on identical or unrelated machines.

Authors: Evripidis Bampis, Bruno Escoffier, Dimitris Fotakis, Giorgos Mitropoulos, Michalis Xefteris

We study learning-augmented algorithms for scheduling on multiple parallel machines under the objectives of minimizing the makespan or the total weighted completion time. We assume that the algorithm has access to noisy information (the prediction) about an optimal solution, expressed through a solution encoding that implicitly quantifies both the amount of information provided and the nature of noise (errors in the prediction). Our central question is to determine the maximum level of noise that still allows for efficiently recovering this optimal solution. We observe that information guiding greedy scheduling to optimality or revealing the optimal assignment of tasks to machines is very sensitive to noise, and prove that recovering an optimal solution from solution encodings capturing either is computationally hard, even for a small (non-constant) number of errors. On the positive side, we show that an order-based encoding, which leads to errors that are dispersed locally, is robust to noise. We present a dynamic programming framework that utilizes this encoding and solves optimally several classical scheduling problems, including makespan and total weighted completion time minimization on identical or unrelated machines.

Real-Time String Indexing in Optimal Time

from arXiv: Data Structures and Algorithms

Authors: Gregory Kucherov, Yakov Nekrich

In this paper we describe the first fully real-time indexing solution for pattern matching over an arbitrary integer alphabet. Our data structure spends $O(1)$ worst-case time w.h.p. for processing each new letter appended to $T$ and worst-case $O(|P|+occ)$ time for reporting all occurrences of $P$, where $T$ and $P$ are strings over an integer alphabet. The main idea of our solution is a novel representation of the suffix tree, the path-decomposed suffix tree, which does not store the full topology of the suffix tree but instead decomposes it into paths, each stored in a dictionary that encodes parent--child relationships indirectly.

Authors: Gregory Kucherov, Yakov Nekrich

In this paper we describe the first fully real-time indexing solution for pattern matching over an arbitrary integer alphabet. Our data structure spends $O(1)$ worst-case time w.h.p. for processing each new letter appended to $T$ and worst-case $O(|P|+occ)$ time for reporting all occurrences of $P$, where $T$ and $P$ are strings over an integer alphabet. The main idea of our solution is a novel representation of the suffix tree, the path-decomposed suffix tree, which does not store the full topology of the suffix tree but instead decomposes it into paths, each stored in a dictionary that encodes parent--child relationships indirectly.

Online Network Design with Maximum Delay and Stochastic Arrivals

from arXiv: Data Structures and Algorithms

Authors: Tianhang Lu

We study online network services that combine pending requests into batches. Each batch pays for its spatial service and for the waiting time of its oldest request. The objective is the sum of these costs over all batches. Thus requests can share both a spatial purchase and one maximum-delay charge. We assume independent Poisson arrivals of known rates, while actual requests are revealed only upon arrival. For stateless services, suppose that each type has an attainable minimum cost when served alone, that every batch costs at least the stand-alone minimum of each type it contains, and that one finite-cost action can serve any batch, regardless of its request multiplicities. We give a deterministic algorithm with long-run ratio of expectations $e/(e-1)$ against an unrestricted offline optimum. This factor is optimal, even allowing randomization, already at one request location. The key comparison measures the union of time intervals associated with requests. The theorem applies directly to multi-root and pair aggregation on trees. We also study facility location, where each request pays its own connection distance and the bounded-action assumption can fail. A deterministic policy gives a ratio $3$ for arbitrary nonnegative opening costs. It immediately serves a finite initial set of requests, computes an assignment from their observed arrival gaps, and then keeps that assignment fixed. Its analysis combines Poisson insertion with a time-slice packing bound on the offline optimum. Every guarantee includes the full cost of completing finite inputs without an end-of-input signal.

Authors: Tianhang Lu

We study online network services that combine pending requests into batches. Each batch pays for its spatial service and for the waiting time of its oldest request. The objective is the sum of these costs over all batches. Thus requests can share both a spatial purchase and one maximum-delay charge. We assume independent Poisson arrivals of known rates, while actual requests are revealed only upon arrival. For stateless services, suppose that each type has an attainable minimum cost when served alone, that every batch costs at least the stand-alone minimum of each type it contains, and that one finite-cost action can serve any batch, regardless of its request multiplicities. We give a deterministic algorithm with long-run ratio of expectations $e/(e-1)$ against an unrestricted offline optimum. This factor is optimal, even allowing randomization, already at one request location. The key comparison measures the union of time intervals associated with requests. The theorem applies directly to multi-root and pair aggregation on trees. We also study facility location, where each request pays its own connection distance and the bounded-action assumption can fail. A deterministic policy gives a ratio $3$ for arbitrary nonnegative opening costs. It immediately serves a finite initial set of requests, computes an assignment from their observed arrival gaps, and then keeps that assignment fixed. Its analysis combines Poisson insertion with a time-slice packing bound on the offline optimum. Every guarantee includes the full cost of completing finite inputs without an end-of-input signal.

Online Network Design with Additive Delays and Poisson Arrivals

from arXiv: Data Structures and Algorithms

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We study online service systems in which requests arrive at locations in a network. A service may open a facility and connect customers, buy a subtree linking them to a root, or send a mobile server to visit them. Combining requests can save opening, network, or travel costs, but each request pays its own waiting time. The objective is the sum of these spatial costs and individual delays. We assume independent Poisson arrivals of known rates. The algorithms know how often requests occur, but observe them only upon arrival. We show that these rates suffice to make fixed spatial choices that compete with an offline optimum free to adapt to the realized input. We obtain long-run ratios of expectations below $27.249$ for facility location in finite metrics, $94.415$ for multi-root aggregation on trees, and $24.326$ for online service on trees. All three algorithms are deterministic; the multi-root algorithm also has polynomial-time preprocessing on rational inputs. The proofs connect rate-based spatial choices with lower bounds on unavoidable purchase, movement, and waiting costs. All main proofs are self-contained, and every guarantee includes the full cost of completing finite inputs.

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We study online service systems in which requests arrive at locations in a network. A service may open a facility and connect customers, buy a subtree linking them to a root, or send a mobile server to visit them. Combining requests can save opening, network, or travel costs, but each request pays its own waiting time. The objective is the sum of these spatial costs and individual delays. We assume independent Poisson arrivals of known rates. The algorithms know how often requests occur, but observe them only upon arrival. We show that these rates suffice to make fixed spatial choices that compete with an offline optimum free to adapt to the realized input. We obtain long-run ratios of expectations below $27.249$ for facility location in finite metrics, $94.415$ for multi-root aggregation on trees, and $24.326$ for online service on trees. All three algorithms are deterministic; the multi-root algorithm also has polynomial-time preprocessing on rational inputs. The proofs connect rate-based spatial choices with lower bounds on unavoidable purchase, movement, and waiting costs. All main proofs are self-contained, and every guarantee includes the full cost of completing finite inputs.

Stochastic Aggregation with Prescribed Resources and Additive Delay

from arXiv: Data Structures and Algorithms

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We study online aggregation with prescribed resources and additive delay. In this problem, we are given a finite set of resources with purchase costs and a collection of request types, each specifying the resources it requires. Requests arrive over time, and each request can be served immediately or postponed to a later time. A service may serve several pending requests together by purchasing every resource required by at least one of them, paying for each purchased resource only once. These purchases serve only the current batch; resources needed in a later service must be purchased again. A request served $t$ units of time after its arrival incurs delay cost $t$. The objective is to serve all requests while minimizing the sum of resource purchase costs and individual delay costs. We consider a stochastic version of this problem in which requests of each type follow an independent Poisson process of known rate. An online algorithm knows these rates but observes requests only upon arrival. We compare its expected cost with that of an offline optimum that knows the entire realized input and may choose every batch freely. A resource--scale linear program supplies both an offline lower certificate and synchronized service periods. This yields a deterministic online algorithm with polynomial-time preprocessing on rational input and a long-run ratio of expectations below $2.113$. The guarantee applies in particular to rooted multi-level aggregation and prescribed-pair aggregation on trees. Besides, for Poisson TCP acknowledgment, we further characterize the optimal long-run ratio of expectations at every load, showing that its worst-case value is approximately 1.409 and is attained by a deterministic online policy.

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We study online aggregation with prescribed resources and additive delay. In this problem, we are given a finite set of resources with purchase costs and a collection of request types, each specifying the resources it requires. Requests arrive over time, and each request can be served immediately or postponed to a later time. A service may serve several pending requests together by purchasing every resource required by at least one of them, paying for each purchased resource only once. These purchases serve only the current batch; resources needed in a later service must be purchased again. A request served $t$ units of time after its arrival incurs delay cost $t$. The objective is to serve all requests while minimizing the sum of resource purchase costs and individual delay costs. We consider a stochastic version of this problem in which requests of each type follow an independent Poisson process of known rate. An online algorithm knows these rates but observes requests only upon arrival. We compare its expected cost with that of an offline optimum that knows the entire realized input and may choose every batch freely. A resource--scale linear program supplies both an offline lower certificate and synchronized service periods. This yields a deterministic online algorithm with polynomial-time preprocessing on rational input and a long-run ratio of expectations below $2.113$. The guarantee applies in particular to rooted multi-level aggregation and prescribed-pair aggregation on trees. Besides, for Poisson TCP acknowledgment, we further characterize the optimal long-run ratio of expectations at every load, showing that its worst-case value is approximately 1.409 and is attained by a deterministic online policy.

List Update with Per-Page Maximum Delay

from arXiv: Data Structures and Algorithms

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We study list update with per-page maximum delay. Requests may wait, and one access clears all pending requests of a page at its current list rank, paying their maximum waiting penalty. Each service can change the permutation and therefore the cost of later accesses. We give a strictly $5$-competitive deterministic algorithm: serve a page when the oldest waiting time reaches two thirds of its current rank, then move it to the front. Our main tool is an asynchronous marked-rank coupling that compares different list orders and different service histories. A temporal transfer principle separates this permutation argument from two waiting-cost inequalities. It gives factor $5$ for page-specific superadditive penalties, common calendar rates, and additional hard deadlines; deadlines alone admit factor $3$. Two structural conditions on request-specific penalties give factor $3+2κ$. In particular, nonincreasing request severity retains factor $5$ even with unbounded weight ratios. For linear delay, offline optimization is NP-complete but fixed-parameter tractable in the number of pages. We characterize fixed-list batching, show an $Ω(m)$ gap between the best static order and dynamic reordering, and prove that the optimal deterministic factor for one page is exactly $2$. Counterexamples delineate the threshold rule's scope.

Authors: Tianhang Lu, Runtian Ren, Shengcai Liu

We study list update with per-page maximum delay. Requests may wait, and one access clears all pending requests of a page at its current list rank, paying their maximum waiting penalty. Each service can change the permutation and therefore the cost of later accesses. We give a strictly $5$-competitive deterministic algorithm: serve a page when the oldest waiting time reaches two thirds of its current rank, then move it to the front. Our main tool is an asynchronous marked-rank coupling that compares different list orders and different service histories. A temporal transfer principle separates this permutation argument from two waiting-cost inequalities. It gives factor $5$ for page-specific superadditive penalties, common calendar rates, and additional hard deadlines; deadlines alone admit factor $3$. Two structural conditions on request-specific penalties give factor $3+2κ$. In particular, nonincreasing request severity retains factor $5$ even with unbounded weight ratios. For linear delay, offline optimization is NP-complete but fixed-parameter tractable in the number of pages. We characterize fixed-list batching, show an $Ω(m)$ gap between the best static order and dynamic reordering, and prove that the optimal deterministic factor for one page is exactly $2$. Counterexamples delineate the threshold rule's scope.

Approximating graphic TSP by b-matchings

from arXiv: Data Structures and Algorithms

Authors: Swati Gupta, Mehrdad Sohrabi, Levent Tunçel

We give a polynomial-time algorithm for graphic TSP that returns a tour of length at most $\frac{89}{64}=\frac{7}{5}-\frac{3}{320}$ times the value of the subtour relaxation. This improves the long-standing ratio $\frac75$ of Sebő and Vygen and shows that the integrality gap of the subtour LP on graphic instances is at most $\frac{89}{64}\approx 1.3906$. We optimize a non-linear objective function over an odd-join polytope, which uses (i) a new removable system of edges, and (ii) reconnection of subtours if the graph is disconnected. This approach gives a $\frac{13}{10}$-approximation algorithm for $4$-regular $4$-vertex-connected graphs, improving the $\frac43$ of Newman, and a $\frac43$-approximation for $k$-vertex-connected graphs of maximum degree at most $k+1$, for every $k\ge 3$. For the general graphic TSP, we construct a feasible point in the odd-join polytope, using an optimal vertex from the Subtour linear programming relaxation of TSP, which helps us bound the approximation factor by 89/64.

Authors: Swati Gupta, Mehrdad Sohrabi, Levent Tunçel

We give a polynomial-time algorithm for graphic TSP that returns a tour of length at most $\frac{89}{64}=\frac{7}{5}-\frac{3}{320}$ times the value of the subtour relaxation. This improves the long-standing ratio $\frac75$ of Sebő and Vygen and shows that the integrality gap of the subtour LP on graphic instances is at most $\frac{89}{64}\approx 1.3906$. We optimize a non-linear objective function over an odd-join polytope, which uses (i) a new removable system of edges, and (ii) reconnection of subtours if the graph is disconnected. This approach gives a $\frac{13}{10}$-approximation algorithm for $4$-regular $4$-vertex-connected graphs, improving the $\frac43$ of Newman, and a $\frac43$-approximation for $k$-vertex-connected graphs of maximum degree at most $k+1$, for every $k\ge 3$. For the general graphic TSP, we construct a feasible point in the odd-join polytope, using an optimal vertex from the Subtour linear programming relaxation of TSP, which helps us bound the approximation factor by 89/64.

Greedy+Singleton for knapsack-constrained monotone submodular maximization has approximation ratio exactly $β^\star \approx 0.42944$

from arXiv: Data Structures and Algorithms

Authors: Kundan Baliga, Aiden Xie, Aditya Byju

Greedy+Singleton is the textbook heuristic for monotone submodular maximization under a knapsack constraint: it returns the better of the cost-benefit greedy set and the best single item. Its worst-case approximation ratio, known only to lie in $[0.427, 0.42945]$ (Feldman-Nutov-Shoham; Kulik-Schwartz-Shachnai), is exactly an explicit constant $β^\star\approx 0.42944$. In the extremal instances, many cheap "filler" items wear down the value of two large optimal items while greedy spends the budget, until neither fits. This picture gives a sharper factor-revealing relaxation; we bound it analytically near the extremal parameters, up to finitely many interval-arithmetic checks, and certify it elsewhere by an exact branch-and-bound. The matching bad instances are tie-free and checkable by hand. For the version that stops at the first item that does not fit, Wolsey's bound $1-e^{-β_W}\approx 0.35780$, where $e^{β_W}=2-β_W$, is tight; Wolsey stated this for his variant without giving the instances, and we give an explicit family with no ties that also covers comparison with the best feasible singleton. The CELF rule also has ratio exactly $β^\star$.

Authors: Kundan Baliga, Aiden Xie, Aditya Byju

Greedy+Singleton is the textbook heuristic for monotone submodular maximization under a knapsack constraint: it returns the better of the cost-benefit greedy set and the best single item. Its worst-case approximation ratio, known only to lie in $[0.427, 0.42945]$ (Feldman-Nutov-Shoham; Kulik-Schwartz-Shachnai), is exactly an explicit constant $β^\star\approx 0.42944$. In the extremal instances, many cheap "filler" items wear down the value of two large optimal items while greedy spends the budget, until neither fits. This picture gives a sharper factor-revealing relaxation; we bound it analytically near the extremal parameters, up to finitely many interval-arithmetic checks, and certify it elsewhere by an exact branch-and-bound. The matching bad instances are tie-free and checkable by hand. For the version that stops at the first item that does not fit, Wolsey's bound $1-e^{-β_W}\approx 0.35780$, where $e^{β_W}=2-β_W$, is tight; Wolsey stated this for his variant without giving the instances, and we give an explicit family with no ties that also covers comparison with the best feasible singleton. The CELF rule also has ratio exactly $β^\star$.

Improved Bounds for Online Matching with Random Edge Arrivals

from arXiv: Data Structures and Algorithms

Authors: Yilong Feng, Haolong Li, Zonghan Yang

We study the unweighted online matching problem with random edge arrivals, where each edge arrives at an independent time drawn uniformly from $[0,1]$, and the algorithm must immediately and irrevocably accept or reject it while maintaining a matching. Guruganesh and Singla (IPCO, 2017) first broke the $1/2$ barrier of the naive Greedy algorithm by giving a $(1/2+\varepsilon)$-competitive algorithm for a small constant $\varepsilon>0$, a guarantee that has remained the best known for nearly a decade. We give a simple three-phase algorithm that achieves a competitive ratio of $0.5445$ by deliberately rejecting selected early edges to reserve their endpoints for later matching opportunities. With a different choice of parameters, the same algorithm is $0.5535$-competitive on triangle-free graphs, including bipartite graphs. We also establish competitive ratio upper bounds below $0.6964$ for general graphs and $0.7043$ for bipartite graphs via exact rational evaluation of an optimal-policy recurrence on fixed graphs, even when the input graph is known up to isomorphism.

Authors: Yilong Feng, Haolong Li, Zonghan Yang

We study the unweighted online matching problem with random edge arrivals, where each edge arrives at an independent time drawn uniformly from $[0,1]$, and the algorithm must immediately and irrevocably accept or reject it while maintaining a matching. Guruganesh and Singla (IPCO, 2017) first broke the $1/2$ barrier of the naive Greedy algorithm by giving a $(1/2+\varepsilon)$-competitive algorithm for a small constant $\varepsilon>0$, a guarantee that has remained the best known for nearly a decade. We give a simple three-phase algorithm that achieves a competitive ratio of $0.5445$ by deliberately rejecting selected early edges to reserve their endpoints for later matching opportunities. With a different choice of parameters, the same algorithm is $0.5535$-competitive on triangle-free graphs, including bipartite graphs. We also establish competitive ratio upper bounds below $0.6964$ for general graphs and $0.7043$ for bipartite graphs via exact rational evaluation of an optimal-policy recurrence on fixed graphs, even when the input graph is known up to isomorphism.

Minimum Membership Dominating Set and Its Generalization: Leafage vs. Asteroidal Number

from arXiv: Data Structures and Algorithms

Authors: Yuma Tamura, Daichi Wakayama, Akira Suzuki, Xiao Zhou

The Dominating Set problem is known to be fixed-parameter tractable when parameterized by leafage, a structural graph parameter defined on chordal graphs. We investigate whether this tractability extends to its variants with natural constraints. Specifically, we study the Minimum Membership Dominating Set problem and its generalization, the Min. $(σ, ρ)$-Dominating Set problem. Given a graph $G$ and a positive integer $\ell$, Minimum Membership Dominating Set asks whether there is a dominating set $D$ such that every vertex in $G$ is dominated by at most $\ell$ vertices in $D$. We first show a negative result: Minimum Membership Dominating Set parameterized by leafage plus $\ell$ is W[1]-hard, demonstrating that even this natural constraint serves as a severe barrier to designing FPT algorithms. To complement this, we present an XP algorithm for the Min. $(σ, ρ)$-Dominating Set problem parameterized by asteroidal number plus $μ$, where $σ$ and $ρ$ are finite sets of non-negative integers and $μ$ is the maximum value in $σ\cup ρ$. Note that asteroidal number generalizes leafage to arbitrary graphs. Combining this algorithm with our structural bound that every graph $G$ admits a dominating set such that no vertex is dominated by more than $7\mathsf{an}(G)-6$ vertices, where $\mathsf{an}(G)$ denotes the asteroidal number of $G$, we show that Minimum Membership Dominating Set admits an XP algorithm parameterized solely by asteroidal number.

Authors: Yuma Tamura, Daichi Wakayama, Akira Suzuki, Xiao Zhou

The Dominating Set problem is known to be fixed-parameter tractable when parameterized by leafage, a structural graph parameter defined on chordal graphs. We investigate whether this tractability extends to its variants with natural constraints. Specifically, we study the Minimum Membership Dominating Set problem and its generalization, the Min. $(σ, ρ)$-Dominating Set problem. Given a graph $G$ and a positive integer $\ell$, Minimum Membership Dominating Set asks whether there is a dominating set $D$ such that every vertex in $G$ is dominated by at most $\ell$ vertices in $D$. We first show a negative result: Minimum Membership Dominating Set parameterized by leafage plus $\ell$ is W[1]-hard, demonstrating that even this natural constraint serves as a severe barrier to designing FPT algorithms. To complement this, we present an XP algorithm for the Min. $(σ, ρ)$-Dominating Set problem parameterized by asteroidal number plus $μ$, where $σ$ and $ρ$ are finite sets of non-negative integers and $μ$ is the maximum value in $σ\cup ρ$. Note that asteroidal number generalizes leafage to arbitrary graphs. Combining this algorithm with our structural bound that every graph $G$ admits a dominating set such that no vertex is dominated by more than $7\mathsf{an}(G)-6$ vertices, where $\mathsf{an}(G)$ denotes the asteroidal number of $G$, we show that Minimum Membership Dominating Set admits an XP algorithm parameterized solely by asteroidal number.

Function Inversion Reporting

from arXiv: Data Structures and Algorithms

Authors: Itai Dinur, Alexander Golovnev, Chao Yan, Yiding Zhu

In the Function Inversion problem, the goal is to invert a function $f:[N] \to [N]$ in two phases. In the preprocessing phase, the offline algorithm computes an advice string of length $S$ bits. In the online phase, the online algorithm receives the advice and a challenge $y \in [N]$, and the goal is to find a preimage $x \in [N]$ such that $f(x) = y$ in time $T$. The problem was initially studied in cryptography, but in recent years it has found various applications to data structure problems. Yet, several of the applications require a variant of Function Inversion, known as Function Inversion Reporting, where the goal is to output all preimages of the challenge $y$. In this paper, we study the Function Inversion Reporting problem in a systematic way by unifying and improving existing algorithms. As a result, we obtain improved data structures for several problems including 3SUM-Indexing Reporting, Range Reporting, Approximate Nearest Neighbor, Jumbled Indexing Reporting, and Gapped String Indexing Reporting.

Authors: Itai Dinur, Alexander Golovnev, Chao Yan, Yiding Zhu

In the Function Inversion problem, the goal is to invert a function $f:[N] \to [N]$ in two phases. In the preprocessing phase, the offline algorithm computes an advice string of length $S$ bits. In the online phase, the online algorithm receives the advice and a challenge $y \in [N]$, and the goal is to find a preimage $x \in [N]$ such that $f(x) = y$ in time $T$. The problem was initially studied in cryptography, but in recent years it has found various applications to data structure problems. Yet, several of the applications require a variant of Function Inversion, known as Function Inversion Reporting, where the goal is to output all preimages of the challenge $y$. In this paper, we study the Function Inversion Reporting problem in a systematic way by unifying and improving existing algorithms. As a result, we obtain improved data structures for several problems including 3SUM-Indexing Reporting, Range Reporting, Approximate Nearest Neighbor, Jumbled Indexing Reporting, and Gapped String Indexing Reporting.

An Improved $(1+2e)$-Approximation Algorithm for Metric Data Placement

from arXiv: Data Structures and Algorithms

Authors: S. Rasoul Etesami

We study the metric data placement problem with site-capacity constraints and fixed installation costs, aiming to minimize the total cost of placing data (resources) and accessing their nearest copies. We develop a deterministic polynomial-time approximation algorithm based on a natural linear programming relaxation of the problem. Starting from an optimal fractional solution, we construct multiscale metric-ball partitions independently for each resource and connect overlapping balls at consecutive levels to form a flow network. The resource layers are then coupled through shared site-capacity arcs, allowing us to obtain an integral placement by minimizing a surrogate cost over a single min-cost circulation. By optimizing the choice of ball radii, we establish an approximation factor of $1+2e\approx 6.44$. To our knowledge, this is the best approximation guarantee for the metric data placement problem since its introduction by Baev and Rajaraman in 2001.

Authors: S. Rasoul Etesami

We study the metric data placement problem with site-capacity constraints and fixed installation costs, aiming to minimize the total cost of placing data (resources) and accessing their nearest copies. We develop a deterministic polynomial-time approximation algorithm based on a natural linear programming relaxation of the problem. Starting from an optimal fractional solution, we construct multiscale metric-ball partitions independently for each resource and connect overlapping balls at consecutive levels to form a flow network. The resource layers are then coupled through shared site-capacity arcs, allowing us to obtain an integral placement by minimizing a surrogate cost over a single min-cost circulation. By optimizing the choice of ball radii, we establish an approximation factor of $1+2e\approx 6.44$. To our knowledge, this is the best approximation guarantee for the metric data placement problem since its introduction by Baev and Rajaraman in 2001.

Beyond the First Hit: Towards Tight Guarantees for $k$-means++

from arXiv: Data Structures and Algorithms

Authors: Aravind Reddy

Let $R_k$ be the worst-case ratio between the expected cost of the $k$ seeds chosen by $k$-means++ and the optimal $k$-means cost. In their seminal paper introducing $k$-means++, Arthur and Vassilvitskii (SODA 2007) showed that $2\ln k\le R_k\le8(\ln k+2)$, and Makarychev, Reddy and Shan (NeurIPS 2020) improved the upper bound to $5(\ln k+2)$. We prove $R_k\le\frac{1163}{233}+2.108\,H_{k-2}$ for every $k\ge3$ by a computer-assisted argument, and $R_k\le5+2.3139\,H_{k-2}$ for every $k\ge2$ by a short analytic argument; here $H_j$ is the $j$th harmonic number. Since $H_{k-2}\le1+\ln k$, this lowers the leading coefficient of $\ln k$ from $5$ to $2.108$. We also determine $R_2=5$ and $R_3=185/32$ exactly; both are suprema that are approached but not attained. On the lower side we prove $R_k\ge2(1+H_{k-1})$ for every $k$, and give a second family of lower bounds that is larger than this for $2\le k\le18$. Previous analyses bound the expected cost of a cluster just after it is first sampled by a constant times its optimal cost, and then charge that cost for the rest of the run. We instead track how a cluster's cost evolves after its first hit: a cluster left with a large residual cost is likely to be sampled again before it accumulates much of the logarithmic charge, and each repeat repairs it.

Authors: Aravind Reddy

Let $R_k$ be the worst-case ratio between the expected cost of the $k$ seeds chosen by $k$-means++ and the optimal $k$-means cost. In their seminal paper introducing $k$-means++, Arthur and Vassilvitskii (SODA 2007) showed that $2\ln k\le R_k\le8(\ln k+2)$, and Makarychev, Reddy and Shan (NeurIPS 2020) improved the upper bound to $5(\ln k+2)$. We prove $R_k\le\frac{1163}{233}+2.108\,H_{k-2}$ for every $k\ge3$ by a computer-assisted argument, and $R_k\le5+2.3139\,H_{k-2}$ for every $k\ge2$ by a short analytic argument; here $H_j$ is the $j$th harmonic number. Since $H_{k-2}\le1+\ln k$, this lowers the leading coefficient of $\ln k$ from $5$ to $2.108$. We also determine $R_2=5$ and $R_3=185/32$ exactly; both are suprema that are approached but not attained. On the lower side we prove $R_k\ge2(1+H_{k-1})$ for every $k$, and give a second family of lower bounds that is larger than this for $2\le k\le18$. Previous analyses bound the expected cost of a cluster just after it is first sampled by a constant times its optimal cost, and then charge that cost for the rest of the run. We instead track how a cluster's cost evolves after its first hit: a cluster left with a large residual cost is likely to be sampled again before it accumulates much of the logarithmic charge, and each repeat repairs it.

Tuesday, November 10

Dana’s talk on OpenAI’s proof of the Unique Games Conjecture, now on YouTube!

from Scott Aaronson

Enjoy all three hours of this! Dana covers what the Unique Games problem is and why people cared about it, the structure of a proof of its NP-hardness, exactly where the previous attempts to complete the proof (based on the Long Code and the Hadamard Code) got stuck, the new tree-based code that the AI […]

Enjoy all three hours of this! Dana covers what the Unique Games problem is and why people cared about it, the structure of a proof of its NP-hardness, exactly where the previous attempts to complete the proof (based on the Long Code and the Hadamard Code) got stuck, the new tree-based code that the AI discovered, and how the new code gets around the Long Code and Hadamard Code’s limitations. She doesn’t get to the soundness analysis.

Feel free to ask questions in the comments. I might write some notes here later with my own doofus understanding of Dana’s talk. Experts are of course hard at work on more formal writeups of the proof (which will hopefully be more comprehensible than the AI’s writeup).

By Scott

TCS+ talk: Wednesday, November 18 — Sahil Singla, Georgia Tech

from TCS+ Seminar Series

The next TCS+ talk will take place next Wednesday, November 18th at 1:00 PM Eastern Time (10:00 AM Pacific Time, 19:00 Central European Time, 18:00 UTC). Sahil Singla from Georgia Tech will discuss recent developments on “The Matroid Secretary Problem” (abstract below). You can reserve a spot as an individual or a group to join […]

The next TCS+ talk will take place next Wednesday, November 18th at 1:00 PM Eastern Time (10:00 AM Pacific Time, 19:00 Central European Time, 18:00 UTC). Sahil Singla from Georgia Tech will discuss recent developments on “The Matroid Secretary Problem” (abstract below).

You can reserve a spot as an individual or a group to join us live by signing up on the online form. Registration is not required to attend the interactive talk, and the link will be posted on the website the day prior to the talk; however, by registering in the form, you will receive a reminder, along with the link. (The recorded talk will also be posted on our website afterwards) As usual, for more information about the TCS+ online seminar series and the upcoming talks, or to suggest a possible topic or speaker, please see the website.

Abstract: In the classic secretary problem, n unknown values are revealed in a uniformly random order, and the goal is to select the maximum. We may select at most one value, and each decision must be immediate and irrevocable. A simple threshold rule selects the maximum with probability at least 1/e. What if we want to select multiple values to maximize their sum, subject to a feasibility constraint? Matroids capture many natural constraints, such as selecting at most k elements or selecting a set of edges with no cycle. In 2007, Babaioff, Immorlica, and Kleinberg conjectured that for every matroid constraint, an online algorithm can obtain a constant fraction of the hindsight optimum value in expectation. In this talk, I will discuss progress on this problem over the past two decades, culminating in the recent resolution of the conjecture in its strong form: achieving a 1/e fraction of the hindsight optimum in expectation, which is best possible even for selecting a single value.

Based on joint work with Hamed Abdi, Kiarash Banihashem, MohammadTaghi Hajiaghayi, Zhiyi Huang, and Danny Mittal, available at arXiv:2611.08869.

By plustcs

nothing left to prove song, and a ripoff of my heroic age post?

from Emanuele Viola

I was pointed to this amusing, but nowadays completely banal, song, and my trained eye spotted a frame that seems to be taken from my previous blog post the heroic age of mathematical exploration: circa 3000 BCE — 2026 CE:

I was pointed to this amusing, but nowadays completely banal, song, and my trained eye spotted a frame that seems to be taken from my previous blog post the heroic age of mathematical exploration: circa 3000 BCE — 2026 CE:

By Manu

IHP school on AI for mathematicians and theoretical physicists

from CS Theory Events

February 22-26, 2027 Institut Henri Poincare, Paris indico.math.cnrs.fr/event/17079/ Registration deadline: November 30, 2026 Recent breakthroughs have shown that AI can now prove theorems. At the same time, many of the deepest open questions in AI are, at heart, questions of mathematics and physics: high-dimensional geometry, non-convex optimisation, the statistical mechanics of learning. AI is becoming … Continue reading IHP school on AI for mathematicians and theoretical physicists

By shacharlovett

February 22-26, 2027 Institut Henri Poincare, Paris https://indico.math.cnrs.fr/event/17079/ Registration deadline: November 30, 2026 Recent breakthroughs have shown that AI can now prove theorems. At the same time, many of the deepest open questions in AI are, at heart, questions of mathematics and physics: high-dimensional geometry, non-convex optimisation, the statistical mechanics of learning. AI is becoming … Continue reading IHP school on AI for mathematicians and theoretical physicists

By shacharlovett

No One Buys Corn in the Corn Market

from Ben Recht

Prediction markets are for gambling. But what part of finance isn’t gambling?

Hi there, argmin readers. Today’s post is a live blog of Class 19 of my graduate seminar “Forecasting: A Critical Retrospective.” In this class, we try to make sense of prediction markets. Good luck to us! The syllabus and list of past posts are here.

On May 16, 2008, in the Policy Forum of Science magazine, two dozen notable scholars called1 on the Commodity Futures Trading Commission (CFTC) to create a safe harbor for prediction markets. In their view, “vibrant, liquid prediction markets” would improve decision-making by “helping businesses make better investment decisions,” “helping governments make better fiscal and monetary policy decisions,” and helping “private firms and public institutions in managing economic risks.” The predictive magic came from the unreasonable efficiency of markets:

“Because information is often widely dispersed among economic actors, it is highly desirable to find a mechanism to collect and aggregate that information. Free markets usually manage this process well because almost anyone can participate, and the potential for profit (and loss) creates strong incentives to search for better information.”

Just two months earlier, on March 17, 2008, the Federal Reserve had convened an emergency meeting, its first in thirty years, to guarantee the failing loans of Bear Stearns and prevent it from collapsing into bankruptcy. The world would quickly plummet into the worst economic recession since the Great Depression. It was the efficiency of markets in action.

Fast forward to 2026, and prediction markets have parasitically clawed their way into ubiquity. Trading volume on sketchy legalized gambling sites Polymarket and Kalshi grew fivefold this year. These companies are also aggressively lobbying the CFTC, but without the technocratic idealism of the 2008 policy wonks. Kalshi and Polymarket are gambling websites, and everyone knows it. But they are using old academic arguments to skirt state gambling laws. The CFTC regulates futures markets. The states regulate gambling. If the CFTC says prediction markets are futures markets, then they are protected from the authority of the states. The Trump family is heavily invested in crypto and prediction markets and is pushing hard to bend the CFTC to their will to enshrine the legal status of the companies.2

The CFTC and its regulatory predecessors have always been tasked with carving out “safe harbors” for futures markets because you have to tie yourself into neoliberal knots to explain how derivatives markets are not gambling. Like most financial instruments, futures markets rest on a simple idea that feels reasonable, but it spirals out of control once you let the invisible hand of the market get to work.

A company that relies on corn production might want to set a price for corn in advance so they can manage risks from volatile harvests. They make a contract with some farm producers before the season, agreeing upon how much they’ll pay per bushel at the end of the season. If there’s a rough harvest, the market price will be considerably higher than the contract price, and the buyer gets their corn at a discount. On the other hand, if the corn harvest is plentiful, the contract price will be higher than the market rate. However, this isn’t the end of the world, because they can buy corn at a cheaper rate from another farmer as supply is abundant. Properly balancing corn on futures contracts and corn at actual prices leads to an expected cost the buyer feels comfortable with. The futures contract serves as a risk management strategy, allowing producers and buyers to hedge against an uncertain market.

Now, a market fundamentalist would argue that for everyone to get the best prices for their businesses, a bigger, more liquid market should be established to determine the right price. People should be able to sell their contracts to each other to dial in the right price as new information emerges. But this ideal world of making all sorts of contracts with different producers and buyers is physically messy. If you wanted to execute all of these deals, you’d have to ship the corn all over the place at harvest time, creating a logistical nightmare. So instead, people created a market for these futures, where you’d sell your futures contract before it ever gets executed. No corn moves anywhere, but money still changes hands. The risk management stuff still works out for all involved, but no one is buying any actual corn in the corn market.

And shoot, if you’re not buying actual corn, why not buy virtual everything else too in these markets? You’re buying a contract on the price of corn, not the corn. You could imagine buying a contract on the price of a financial instrument, like a stock price or an interest rate. This would help you manage risk in an investment portfolio. After its establishment in the 1970s, the CFTC began liberally including all sorts of futures in its “no, this is actually not gambling” bucket. Sure, you’re not buying anything in these markets except contracts on future prices. But it was of economic value to allow such speculation. The CFTC still discouraged derivative contracts on “events” that didn’t have a clear economic purpose.

Meanwhile, egghead economists argued the CFTC should relax. Any event can be securitized, and this securitization is good for everyone. Ken Arrow and Gerard Debreu won the Sveriges Riksbank Prize in Economic Sciences in Memory of Alfred Nobel for this sort of thinking. Inspired, economists in Iowa started running fake markets to predict the outcome of the Iowa caucuses. And people like Phil Tetlock started to run competitions with IARPA to improve forecasting geopolitical turmoil. But prediction markets add another layer of derivatives. Betting on events lets decision makers discover probabilities they can plug into expected-value calculations, so they know how to price commodity futures contracts. I guess?

I am personally fascinated by this pattern of derivatization in finance. Derivatives feel sensible for risk management, but require creating a bizarre abstraction of the object you’d like to hedge against. These derivatives aren’t necessarily gambling, but derivatives on derivatives are always gambling. There’s no way to avoid the cascade into speculation once you financialize reality.

Prediction markets are a hilarious caricature of neoliberal economics. In prediction markets, everything is gambling, and everyone knows it. No matter what the rationalist disciples of Tetlock tell you, there’s no sensible defense of the prediction markets. They don’t produce probabilities in any reasonable sense, in theory or in practice. They don’t inform decision-making. They are not “efficient,” as no markets are efficient. The prediction market companies exist entirely for gambling. And gamblers love them.

If you want to defend them, you need to embrace a certain style of hyper-rational thinking that we’ve mistakenly normalized. We are told that the predictions are good because markets are the ultimate information aggregators, and the information is good because people in markets have skin in the game. But who takes advice from degenerate gamblers?

Subscribe now

1

I mean, look at this author list. The argmin nightmare blunt rotation. Kenneth Arrow, Robert Forsythe, Michael Gorham, Robert Hahn, Robin Hanson, John Ledyard, Saul Levmore, Robert Litan, Paul Milgrom, Forrest D. Nelson, George R. Neumann, Marco Ottaviani, Thomas C. Schelling, Robert J. Shiller, Vernon L. Smith, Erik Snowberg, Cass Sunstein, Paul Tetlock, Philip Tetlock, Hal R. Varian, Justin Wolfers, Eric Zitzewitz.

2

For more on these developments, read John Cassidy’s reporting “This Is What Trumpian Self-Dealing Looks Like” in The New Yorker.

By Ben Recht

TR26-316 | Hard Instances for Strong Semantic Proof Systems: CNFs for Depth-Four PC and Deep Instances for AC0[2]-Frege | Yaroslav Alekseev, Svyatoslav Gryaznov, Dmitry Itsykson, Toniann Pitassi, Robert Robere, Iddo Tzameret

from ECCC Papers

We establish a collection of new size lower bounds against fairly strong algebraic-Boolean propositional proof systems, from depth-3 semantic polynomial calculus for CNFs, up to semantic $AC^0[2]$-Frege in the regime of deep formulas, as follows: (1) $\Sigma\Pi\Sigma$-PC: Exponential lower bound against semantic $\Sigma\Pi\Sigma$-PC over $F_2$, namely, polynomial calculus operating with depth-3 circuits with sum top gate, for the bit pigeonhole principle. We further obtain $2^{\Omega(n)}$ lower bounds for random 3-CNFs on $n$ variables and for the bit and functional pigeonhole principles with $n+1$ pigeons and $n$ holes. (2) $\Sigma\Pi\Sigma\Pi$-PC: Superpolynomial lower bounds for semantic $\Sigma\Pi\Sigma\Pi$-PC over $F_2$, with unrestricted bottom fan-in. The hard instances include the weak unary pigeonhole principle and lifting of random CNFs of logarithmic width. For the weak pigeonhole principle with $2n$ pigeons and $n$ holes, the lower bound is $\exp(\Omega((\log n)^2/\log\log n))$. This further settles the open problem of establishing superpolynomial lower bounds against $\mathrm{Res}(\log)$ for this principle. When the $\Sigma\Pi\Sigma\Pi$-PC bottom fan-in is logarithmic, we obtain exponential lower bounds for random CNFs of logarithmic width. (3) Depth-$d$ $AC^0[2]$-Frege: For every fixed $d\ge 2$, we construct unsatisfiable families of formulas of depth $d$ that require superpolynomial-size semantic depth-$d$ $AC^0[2]$-Frege refutations, but have polynomial-size semantic depth-$(d+1)$ $AC^0[2]$-Frege refutations. This provides the first unconditional hard instances against arbitrary depth $AC^0[2]$-Frege. The arguments build and expand on the recent AI-generated proof of an exponential lower bound against resolution over parities by Braun [16]. We distil Braun's implicit annihilating polynomial argument into an abstract framework based on standard pseudo-reduction operators, and augment it with new techniques. We show how rank lower bounds for these operators imply proof-size lower bounds. The polynomial approximation method of Razborov and Smolensky [60, 64] extends the framework to bounded bottom degree. Lifting and random restrictions remove the restriction on bottom fan-in. For the $AC^0[2]$-Frege result, we combine polynomial approximation with the common annihilating polynomial and a lifting construction based on constant-depth formulas for the coin problem.
We establish a collection of new size lower bounds against fairly strong algebraic-Boolean propositional proof systems, from depth-3 semantic polynomial calculus for CNFs, up to semantic $AC^0[2]$-Frege in the regime of deep formulas, as follows: (1) $\Sigma\Pi\Sigma$-PC: Exponential lower bound against semantic $\Sigma\Pi\Sigma$-PC over $F_2$, namely, polynomial calculus operating with depth-3 circuits with sum top gate, for the bit pigeonhole principle. We further obtain $2^{\Omega(n)}$ lower bounds for random 3-CNFs on $n$ variables and for the bit and functional pigeonhole principles with $n+1$ pigeons and $n$ holes. (2) $\Sigma\Pi\Sigma\Pi$-PC: Superpolynomial lower bounds for semantic $\Sigma\Pi\Sigma\Pi$-PC over $F_2$, with unrestricted bottom fan-in. The hard instances include the weak unary pigeonhole principle and lifting of random CNFs of logarithmic width. For the weak pigeonhole principle with $2n$ pigeons and $n$ holes, the lower bound is $\exp(\Omega((\log n)^2/\log\log n))$. This further settles the open problem of establishing superpolynomial lower bounds against $\mathrm{Res}(\log)$ for this principle. When the $\Sigma\Pi\Sigma\Pi$-PC bottom fan-in is logarithmic, we obtain exponential lower bounds for random CNFs of logarithmic width. (3) Depth-$d$ $AC^0[2]$-Frege: For every fixed $d\ge 2$, we construct unsatisfiable families of formulas of depth $d$ that require superpolynomial-size semantic depth-$d$ $AC^0[2]$-Frege refutations, but have polynomial-size semantic depth-$(d+1)$ $AC^0[2]$-Frege refutations. This provides the first unconditional hard instances against arbitrary depth $AC^0[2]$-Frege. The arguments build and expand on the recent AI-generated proof of an exponential lower bound against resolution over parities by Braun [16]. We distil Braun's implicit annihilating polynomial argument into an abstract framework based on standard pseudo-reduction operators, and augment it with new techniques. We show how rank lower bounds for these operators imply proof-size lower bounds. The polynomial approximation method of Razborov and Smolensky [60, 64] extends the framework to bounded bottom degree. Lifting and random restrictions remove the restriction on bottom fan-in. For the $AC^0[2]$-Frege result, we combine polynomial approximation with the common annihilating polynomial and a lifting construction based on constant-depth formulas for the coin problem.