Theory of Computing Report

Authors: Nirmit Joshi, Roey Magen, Nathan Srebro, Nikolaos Tsilivis, Gal Vardi

We study learning with Chain-of-Thought (CoT) supervision from multiple thinkers, all of whom provide correct but possibly systematically different solutions, e.g., step-by-step solutions to math problems written by different thinkers, or step-by-step execution traces of different programs solving the same problem. We consider classes that are computationally easy to learn using CoT supervision from a single thinker, but hard to learn with only end-result supervision, i.e., without CoT (Joshi et al. 2025). We establish that, under cryptographic assumptions, learning can be hard from CoT supervision provided by two or a few different thinkers, in passive data-collection settings. On the other hand, we provide a generic computationally efficient active learning algorithm that learns with a small amount of CoT data per thinker that is completely independent of the target accuracy $\varepsilon$, a moderate number of thinkers that scales as $\log \frac{1}{\varepsilon}\log \log \frac{1}{\varepsilon}$, and sufficient passive end-result data that scales as $\frac{1}{\varepsilon}\cdot poly\log\frac{1}{\varepsilon}$.

Authors: Olivier Bournez

What do recurrent neural networks, polynomial ODEs, and discrete polynomial maps each bring to computation, and what do they lack? All three operate over the continuum--real-valued states evolved by real-valued dynamics--even when the target functions are discrete. We study them through primitive recursion. We prove that primitive recursion admits equivalent characterizations in all three frameworks: bounded iteration of a fixed recurrent ReLU network, robust computation by a fixed polynomial ODE, and iteration of a fixed polynomial map with an externally supplied step-size parameter. In each, the time bound is itself primitive recursive, composition emerges from the dynamics rather than as a closure rule, and inputs are raw integer vectors. Every primitive recursive function is first compiled into bounded iteration of a single threshold-affine normal form, then interpreted as a ReLU computation and as a polynomial ODE. The equivalences expose a structural asymmetry: no fixed polynomial map can round uniformly to the nearest integer or realize exact phase selection--operations polynomial ODEs perform robustly via continuous-time flow. Each formalism compensates for a limitation the others lack: the ReLU gate provides exact branching, continuous time provides autonomous rounding and control, and the step-size parameter recovers both at the cost of discretization precision. This opens dynamical characterizations of subrecursive hierarchies and complexity classes by restricting time bounds, polynomial degrees, or discretization resources within one framework. More broadly, these models do not compute by composing subroutines: they shape the trajectory of a dynamical system through clocks, phase selectors, and error correction built into the dynamics. This differs structurally from symbolic programming, and our theorem gives a precise framework to study the difference.

Authors: Srijan Chakraborty, Samir Datta, Aryan Kusre, Partha Mukhopadhyay, Amit Sinhababu

Understanding the power of space-bounded computation with access to catalytic space has been an important theme in complexity theory over the recent years. One of the key algorithmic results in this area is that bipartite maximum matching can be computed in catalytic logspace with a polynomial-time bound, Agarwala and Mertz (2025). In this paper, we show that we can construct a \emph{maximum matching} in \emph{general graphs} in CL, and, in fact, in CLP. We first show that the size of a \emph{maximum matching} in \emph{general graphs} can be determined in CL. Our algorithm is based on the linear-algebraic algorithm for maximum matching by Geelen (2000). We then show that this algorithm, along with some new ideas, can be used to \emph{find} a maximum matching in general graphs. Using a similar algorithm of Geelen (1999), we also solve the \emph{maximum rank completion problem} in CLP, which was previously known to be solvable in deterministic polynomial time, Geelen. This problem turns out to be equivalent to the \emph{linear matroid intersection} problem (shown by Murota, 1995) which has been shown to be in CLP by Agarwala, Alekseev, and Vinciguerra (2026). Finally, using a PTAS algorithm Bläser, Jindal and Pandey (2018), for approximating the rank in Edmond's problem, we derive a CLP algorithm that can approximate the rank given by any instance of the \emph{Edmond's problem} upto a factor of $(1-\eps)$ for any $\eps\in(0,1)$. An application of this is a CLP bound for approximating the maximum independent matching in the \emph{linear matroid matching} problem.

Authors: Marius Bozga, Radu Iosif, Florian Zuleger

Series-parallel (SP) graphs are binary edge-labeled graphs with a designated source and target vertex, built using serial and parallel composition. A set of graphs is recognizable if membership depends only on its image under a homomorphism into a finite algebra. For SP-graphs, and more generally, for graphs of bounded tree-width, recognizability coincides with definability in Counting Monadic Second-Order (CMSO) logic. Despite this strong logical characterization, the conciseness and algorithmic effectiveness of syntactic representations of recognizable sets of SP (and bounded-tree-width) graphs remain poorly understood. Building on previously introduced regular grammars for SP-graphs, we show that recognizable sets admit concise and effective syntactic representations. The main contribution is an improved construction of finite recognizer algebras whose size is singly-exponential in the size of a regular grammar, improving upon the previously known double-exponential bound. As a consequence, the problems of intersection and language inclusion for sets represented by regular grammars are shown to be ExpTime-complete, thus improving on a previously known 2ExpTime upper bound.

Authors: Aleksandr Koshkarov, Nadia Tahiri

Comparative analyses of phylogenetic trees typically require identical taxon sets, however, in practice, trees often include distinct but overlapping taxa. Pruning non-shared leaves discards phylogenetic signal, whereas tree completion can preserve both taxa and branch-length information. This work introduces a polynomial-time algorithm for set-wide completion of phylogenetic trees with partial taxon overlap. The proposed method identifies and extracts maximal completion subtrees that frequently appear across the source trees and constructs a weighted majority-rule consensus. Branch lengths are scaled using rates derived from common leaves. Each consensus subtree is inserted at the position that minimizes the quadratic distance error measured against information from the source trees, with candidate positions restricted to the original branches of the target tree. We demonstrate that the algorithm runs in polynomial time and preserves distances among the original taxa, yielding a unique completion that is order-independent with respect to the processing order of target trees. An experimental evaluation on amphibians, mammals, sharks, and squamates shows that the proposed method consistently achieves the lowest distance to the subset reference trees across subsets among all methods, in both topology and branch lengths. An open-source Python implementation of the proposed algorithm and the biological datasets utilized in this study are publicly available at: https://github.com/tahiri-lab/overlap-treeset-completion/.

Authors: Marco Carmosino, Ngu Dang, Tim Jackman

Gate elimination is the primary technique for proving explicit lower bounds against general Boolean circuits, including Li and Yang's state-of-the-art $3.1n - o(n)$ bound for affine dispersers (STOC 2022). Every circuit lower bound is implicitly existential: every circuit that is too small to compute $f$ must err on some input. This raises a natural question: are these lower bounds \emph{constructive}? That is, can we efficiently produce such errors? Chen, Jin, Santhanam, and Williams showed that constructivity plays a central role in many longstanding open problems in complexity theory, and explicitly raised the question of which circuit lower bound techniques can be made constructive (FOCS 2021). We show that a variety of gate elimination arguments yield refuters -- efficient algorithms that, when given a circuit that is too small to compute a function $f$, produce an input on which the circuit errs. Our results range from elementary lower bounds for $XOR$ and the multiplexer to more sophisticated arguments for affine dispersers. Underlying these results is a shift in perspective: gate elimination arguments \emph{are} algorithms. Each step either simplifies the circuit or reveals a violation of some structural or functional property, from which, with a little additional work, explicit counterexamples can be extracted. We further strengthen the $XOR$ result to handle circuits that \emph{match} the lower bound: given any DeMorgan circuit of size $3(n-1)$ that fails to compute $XOR_n$, we can efficiently produce a counterexample. While refuters follow from the gate elimination arguments themselves, this refinement requires a complete characterization of the set of optimal circuits computing $XOR$ -- a requirement rarely met by other explicit functions.

Authors: Arnaud Casteigts, Christian Komusiewicz, Nils Morawietz

Temporal graphs are graphs whose edges are only present at certain points in time. Reachability in these graphs relies on temporal paths, where edges are traversed chronologically. A temporal graph that offers all-pairs reachability is said to be temporally connected (or TC). For temporal graphs that are not TC, a natural question is whether they admit a TC subgraph (a.k.a. closed temporal component) of a given size $k$. This question was one of the earliest in the field, shown to be NP-hard by Bhadra and Ferreira in 2003. We strengthen this result dramatically, showing that deciding if a TC subgraph exists on at least $3$ vertices is already NP-hard in all the standard temporal graph settings (directed/undirected and strict/non-strict through simple and proper reductions). This implies a strong separation between closed temporal components and open temporal components (where temporal paths can travel outside the component), for which inclusion-maximal components can be found in polynomial time. As a by-product, our reductions strengthen a number of existing results and establish new derived results. They imply that the size of the largest TC subgraph cannot be approximated within a factor of $(1-ε)n$ in directed graphs, and within a factor of $(1-ε)\frac{n}{2}$ in undirected graphs. One of the reductions also completes the complexity landscape for TC subgraphs of size exactly $k$ when parameterized by $k$ (answering the missing non-strict case). Finally, on the structural side, our results imply that there exist arbitrarily large TC graphs of constant lifetime without nontrivial TC subgraphs, and we also show that there exist TC graphs of arbitrary girth, both facts being of independent interest.

Authors: Kenta Watanabe

For a smooth irreducible curve $C$, its second gonality $d_2$ is defined to be the minimum integer $d$ such that $C$ admits a linear series $g_d^2$. In this paper, we compute the second gonality of a smooth aCM curve $C$ lying on a smooth quartic surface in $\mathbb{P}^3$, whose Clifford index is computed by a net on $C$.

Authors: Jacobus Conradi, Ivor van der Hoog, Frederikke Uldahl, Eva Rotenberg

The Fréchet distance is a popular distance measure between trajectories or curves in space, or between walks in graphs. We study computing the Fréchet distance between walks in the $d$-dimensional grid graphs, i.e. $\mathbb{Z}^d$ where points share an edge if they differ by one in one coordinate. We give an algorithm, that for two simple paths on $n$ vertices, $(1+\varepsilon)$-approximates the Fréchet distance in time $\widetilde{O}((\frac{n}{\varepsilon})^{2-2/d} +n)$. We complement this by a near-matching fine-grained lower bound: for constant dimensions $d \geq 3$, there is no $O((\varepsilon^{2/d}(\frac{n}{\varepsilon})^{2-2/d})^{1-δ})$ algorithm for any $δ>0$ unless the Orthogonal Vector Hypothesis fails. Thus, our results are tight up to a factor $\varepsilon^{2/d}$ and $\log(n)$-factors. We extend our results to imbalanced lower and upper bounds, where the curves have $n$ and $m$ vertices respectively, and also obtain near-tight bounds. Driemel, Har-Peled and Wenk [DCG'12] studied \emph{realistic assumptions} for curves to speed up Fréchet distance computation. One of these assumptions is $λ$-low density and they can compute a $(1+\varepsilon)$-approximation between $λ$-low dense curves in time $\widetilde{O}( \varepsilon^{-2} λ^2 n^{2(1-1/d)})$. By adapting our lower bound, we show that their algorithm has a tight dependency on $n$ and a tight dependency on $\varepsilon$ as $d$ goes to infinity. A gap remains in terms of $λ$.

Authors: Daniel Bertschinger, Henry Förster, Fabian Klute, Irene Parada, Patrick Schnider, Birgit Vogtenhuber

We study the common intersection of arrangements of double-wedges. We consider arrangements where double-wedges may be either bowties (which do not contain a vertical line) or hourglasses (which contain a vertical line), in contrast to earlier studies that focused on arrangements of only bowties. This generalization changes the setting drastically, in particular, with respect to all arguments involving the point-line duality. Namely, a point in the intersection of all double-wedges is equivalent to a line that stabs a set of segments $\mathcal{S}$ (corresponding to the bowties) while it avoids a different set of segments $\mathcal{A}$ (corresponding to the complement of the hourglasses). We show that in this general setting, the intersection of $n$ double-wedges may consist of $Ω(n^2)$ interior-disjoint regions. Further, we discuss Gallai-type results for arrangements of segments and anti-segments, and we provide algorithms for computing the intersection of such arrangements with worst-case optimal running time. Finally, we also prove that we can find a single intersection point in almost optimal running time, assuming that 3SUM admits no truly subquadratic-time algorithm.

Authors: Sariel Har-Peled

Consider a stream of $n$ random points (say, from the unit square) arriving one by one, where a player has to make an irreversible immediate decision for each arriving point whether to pick it. The player has to pick a single point, and the payoff is the area of the cell of the picked point, in the final Voronoi diagram of \emph{all} the points. We show that there is a simple strategy so that with probability $\geq 1 - \tilde O(1/\sqrt{n})$, the player's payoff is only a constant factor smaller than the optimal choice (i.e., the one made by the prophet). This competitiveness is somewhat surprising, as this payoff is larger by a factor of $Θ( \log n)$ than the average payoff.

Authors: Petr A. Golovach, Laure Morelle, Daniël Paulusma

An identification of two vertices $u$ and $v$ in a graph replaces them with a new vertex whose neighborhood is the union of the neighborhoods of $u$ and $v$. We study the {\sc ${\cal H}$-Identification} problem, which is to decide whether a given graph $G$ can be transformed (``identified'') to a graph in ${\cal H}$ by applying at most $k$ vertex identifications. We determine the classical and parameterized complexity of this problem for various subclasses ${\cal H}$ of chordal graphs, obtaining an almost complete picture for two parameters: $k$ and $n-k$. We also consider the {\sc Identification} problem, which is to test for two given graphs $G$ and $H$ if $G$ can be identified to $H$. We determine the parameterized complexity of this problem when $H$ is a graph from one of our testbed classes, taking the number of simplicial vertices of $H$ as the parameter.

Authors: Tala Eagling-Vose, Barnaby Martin, Daniël Paulusma, Nicolas Trotignon

We consider the $H$-Induced Minor problem: for a fixed graph~$H$, decide whether a given graph $G$ contains $H$ as an induced minor. While the problem is known to be NP-complete for some trees~$H$ on more than $2^{300}$ vertices, the complexity for small trees remains unresolved. In particular, the case where $H$ is the $7$-vertex tree consisting of a path on five vertices with a pendant vertex attached to the second and fourth vertex was a long-standing open problem. We show that this case is polynomial-time solvable by developing algorithms that detect a sequence of carefully chosen substructures. Complementing this, we prove that detecting some of these substructures individually is NP-hard. We also give polynomial-time algorithms for three cases where $H$ is a graph on five vertices (that is not a tree). In this way, we completed the classification of $H$-Induced Minor for graphs $H$ on five vertices and answered an open problem of Dallard, Dumas, Hilaire and Perez (2025).

Authors: Mark de Berg, Bart M. P. Jansen, Jeroen S. K. Lamme

We study SINGLE-SOURCE SHORTEST PATH (SSSP) on unweighted intersection graphs whose node set corresponds to a set of $n$ constant-complexity objects in the plane. We prove SSSP can be solved in $O(U(n)\ \mathrm{polylog}\,n)$ expected time for any class of objects whose union complexity is $U(n)$. In particular, we obtain an $O(n 2^{α(n)}\log^2 n)$ algorithm for arbitrary pseudodisks, and an $O(λ_{s+2}(n)2^{O(\log^* n)} \log^2 n)$ algorithm for locally fat objects. This significantly extends the class of objects for which SSSP can be solved in $O(n\ \mathrm{polylog}\, n)$ time: so far, $O(n\ \mathrm{polylog}\, n)$ SSSP algorithms were not even known for pseudodisks that are fat and convex and similarly-sized. Our second result concerns the DIAMETER problem, which asks for the maximum distance between any two nodes in a graph. Even for intersection graphs, near-quadratic algorithms are difficult to obtain, and the $O(n^2\ \mathrm{polylog}\, n)$ running time that follows from our SSSP algorithm is the first near-quadratic running time for such general classes of intersection graphs. Obtaining subquadratic running time is even more challenging. We prove that the diameter of a set of arbitrary pseudodisks can be computed almost exactly, namely up to an additive error of 2, in $\tilde{O}(n^{2-1/14})$ expected time. This generalizes and speeds up a recent algorithm by Chang, Gao, and Le~(SoCG 2024) that works for similarly-sized disks (or similarly-sized pseudodisks that are fat and satisfy a strong monotonicity assumption) and runs in $\tilde{O}(n^{2-1/18})$ time. To this end, we develop a so-called star-based $r$-clustering for intersection graphs of pseudodisks, which is interesting in its own right. Our star-based $r$-clustering can also be used to obtain an almost exact distance oracle for pseudodisks that uses $O(n^{2-1/13})$ storage and has $O(1)$ query time.

Authors: Jugal Garg, Shayan Taherijam, Vijay V Vazirani

Our main contribution is a strongly polynomial algorithm for computing an equilibrium for the Arctic Auction, which is the quasi-linear extension of the linear Fisher market model. We build directly on Orlin's strongly polynomial algorithm for the linear Fisher market (Orlin, 2010). The first combinatorial polynomial algorithm for the linear Fisher market was based on the primal-dual paradigm (Devanur et al., 2008). This was followed by Orlin's scaling-based algorithms. The Arctic Auction (Klemperer 2018) was developed for the Government of Iceland to allow individuals to exchange blocked offshore assets. It is a variant of the product-mix auction (Klemperer 2008, 2010, 2018) that was designed for, and used by, the Bank of England, to allocate liquidity efficiently across banks pledging heterogeneous collateral of varying quality. Our work was motivated by the fact that banks often need to run Arctic Auctions under many different settings of the parameters in order to home in on the right one, making it essential to find a time-efficient algorithm for Arctic Auction.

Authors: Petr A. Golovach, Diptapriyo Majumdar, Saket Saurabh

Given a connected undirected graph $G$, a spanning tree is a subgraph $T$ of $G$ such that $V(T) = V(G)$ and $T$ is a tree. A collection of $\ell$ spanning trees $T_1,\ldots,T_\ell$ is pairwise $k$-diverse if for every $i \neq j$, $|E(T_i) \triangle E(T_j)| \geq k$. Given a connected undirected graph $G$ and integers $p, q, k, \ell$, Leaf & Internal-Constrained Diverse Spanning Trees asks whether there are $\ell$ distinct spanning trees $T_1,\ldots,T_{\ell}$ of $G$ that are pairwise $k$-diverse such that each tree has at least $p$ leaves and at least $q$ internal vertices. Similarly, Leaf & Non-terminal-Constrained Diverse Spanning Trees takes a connected undirected graph $G$, $V_{NT}\subseteq V(G)$, and three integers $p, k, \ell$, and asks if $G$ has $\ell$ spanning trees that are pairwise $k$-diverse, and each has at least $p$ leaves and conains the vertices of $V_{NT}$ as internal. We consider these two problems from the kernelization perspective and provide polynomial kernels for Leaf & Internal-Constrained Diverse Spanning Trees and Leaf & Non-terminal-Constrained Diverse Spanning Trees, when parameterized by $p + q + k + \ell$ and $p + |V_{\rm NT}| + k + \ell$, respectively.

Authors: Yuexin Su, Chenyi Zhang, Peiyuan Huang, Tongyang Li, Yinyu Ye

Computing approximate Karush--Kuhn--Tucker (KKT) points for constrained nonconvex programs is a fundamental problem in mathematical programming. Interior-point trust-region (IPTR) methods are particularly attractive for such problems because they maintain strictly feasible iterates throughout the iterative process and converge to a first-order and second-order KKT solution. Their scalability, however, is limited by the repeated computation of trust-region search directions. In this paper, we propose an approximate first-order IPTR framework that addresses this bottleneck by replacing exact trust-region subproblem solves with an approximate projector maintained through low-rank updates. The resulting method preserves feasibility and the global convergence guarantees of standard IPTR schemes while substantially reducing the per-iteration cost. We further extend the framework to obtain approximate second-order KKT points using only first-order information by integrating a gradient-based negative-curvature routine, thus avoiding explicit Hessian computations. We conduct numerical experiments to demonstrate the scalability of our approximate first-order IPTR framework in large-scale settings, where it achieves up to a $2.48\times$ speedup over the existing first-order IPTR algorithm.

Authors: Paweł Rafał Bieliński, Marta Piecyk, Paweł Rzążewski

The complexity of classical computational problems in graph classes defined by forbidding induced subgraphs is one of the central topics of algorithmic graph theory. Recently, there has been a growing interest in the complexity of such problems in ordered graphs, i.e., graphs with a fixed linear ordering of vertices. Such an approach allows us to investigate the boundary of tractability more closely. However, most results so far concern coloring problems. In this paper, we focus on the complexity of the Maximum Weight Independent Set (MWIS) problem in classes of ordered graphs. For every ordered graph $H$, we classify the complexity of MWIS in ordered graphs that exclude $H$ as an induced subgraph into one of the following cases: (1) solvable in polynomial time, (2) solvable in quasipolynomial time, (3) solvable in subexponential time, (4) NP-hard. Notably, case (3) contains only one well-structured family of $H$ obtained from two nested edges by adding isolated vertices in a specific way. Thus, our results yield an almost complete complexity dichotomy for MWIS in classes of ordered graphs defined by a single forbidden induced subgraph into cases solvable in quasipolynomial time and those that are NP-hard.

Authors: Luca Becchetti, Andrea Clementi, Luciano Gualà, Emanuele Natale, Luca Pepè Sciarria, Alessandro Straziota

The Approximate Near Neighbor (ANN) problem is a cornerstone in high-dimensional data analysis, with applications ranging from information retrieval to data mining. Among the most successful paradigms for solving ANN in high-dimensional metric spaces is Locality Sensitive Hashing (LSH), alongside the more recent Locality Sensitive Filtering (LSF). Since the seminal work of Indyk and Motwani, literature has expanded into a complex landscape of variants, often presented under different perspectives and adopting different notation. In this work, we address the technical challenge of navigating this landscape, by providing a self-contained, unified view of the essential algorithmic ingredients governing LSH-based and LSF-based solutions for angular distance -- a case of particular relevance in modern applications. In doing so, we touch on deep connections between LSF and LSH strategies. Our contribution is twofold. First, we design and analyze an LSF-based data structure for the Angular ANN problem, serving as a "guided tour" through fundamental techniques and results in the area. Second, we provide a streamlined analysis that, piecing together technical ingredients and results appeared throughout previous literature, proves optimality of the proposed data structure. In doing so, we revisit and strengthen a key technical lemma central to this body of work. The result is a critical and cohesive review that identifies core mechanisms of proximity search, offering both a streamlined entry point for researchers and a refined perspective on the state of the art.

Authors: Nguyen Khoa Tran, Lin Mu, Martin Papenberg, Gunnar W. Klau

The $k$-Maximum Dispersion Problem with Cardinality Constraints ($k$-MDCC) asks for a partition of a given item set with pairwise dissimilarities into $k$ cardinality-constrained groups such that the minimum pairwise intra-group dissimilarity, which is also known as the dispersion, is maximized. The problem arises in the context of anticlustering, where the goal is to create maximally heterogeneous groups of items with applications in psychological research, bioinformatics, and data science. It is known that $k$-MDCC is NP-hard for $k \geq 3$ but it has been an open question whether it can be solved in polynomial time for $k = 2$. We give a positive answer to this question by showing that $2$-MDCC can be solved by a quadratic number of cardinality-constrained 2-coloring problem instances ($2$-COLCC). We solve these instances by transforming them into a restricted class of subset sum instances. Although subset sum is NP-complete in general, for this restricted class the input values are bounded, ensuring that the pseudopolynomial dynamic programming algorithm runs in polynomial time. As a consequence, we obtain a polynomial-time algorithm for $2$-MDCC. We demonstrate that a publicly available open-source implementation of our new algorithm outperforms the previous integer linear programming solution by several orders of magnitude so that even large datasets ($n = 10{,}000$) can be processed in less than a second.

Authors: Simeon Pawlowski, Vincent Froese

We study an interval ordering problem introduced by Dürr et al. [Discrete Appl. Math. 2012] which is motivated by applications in bioinformatics. The task is to order a given set of n intervals with the goal of minimizing a certain objective which is defined via a given cost function $f$ which assigns a cost to the exposed part of each interval (that is, the pieces not covered by previous intervals). We develop a dynamic programming approach which solves the problem with $O(2^n\text{poly}(n))$ oracle calls to $f$ and arithmetic operations. Moreover, our approach yields polynomial-time algorithms for all cost functions $f$ such that $f-f(0)$ is subadditive or superadditive. This answers an open question for the function $f(x)=2^x$. We contrast these results by proving a running time lower bound of $2^{n-1}$ for any algorithm that solves the problem for every function $f$ (with oracle access only) and further proving NP-hardness for very restricted classes of functions. Thus, we significantly narrow the gap regarding the computational complexity of the problem.

Authors: Marta Piecyk, R. B. Sandeep

Subdividing an edge $uv$ in a graph replaces it by a path $u w v$ with one new vertex. For a graph $H$, the \textsc{$H$-free Subdivision} problem asks whether, given a graph $G$ and an integer $k$, one can destroy all induced copies of $H$ in $G$ by at most $k$ edge subdivisions. We show that the problem is polynomial-time solvable when every component of $H$ is a subdivided star or a subdivided bistar, and at most one component is a subdivided bistar. On the other hand, we prove that \textsc{$H$-free Subdivision} is NP-complete and, assuming the Exponential Time Hypothesis, admits no $2^{o(k)} n^{O(1)}$-time algorithm whenever $H$ satisfies any of the following conditions: \begin{itemize} \item $H$ has minimum degree at least $2$, and the neighborhood of every degree-$2$ vertex induces a $K_2$; \item the vertices of degree at least $3$ in $H$ induce a graph with at least two edges; \item $H$ has a triangle with two vertices of degree at least $3$; \item $H$ contains, as an induced subgraph, the graph obtained from two vertex-disjoint triangles by adding one edge between them; \item $H$ contains exactly one triangle; \item $H$ has girth at least $4$; \item $H$ is a tree with exactly two vertices of degree at least $3$ at distance $2$ or at least $4$. \end{itemize} A simple bounded search-tree algorithm for the problem runs in $2^{O(k)} n^{O(1)}$ time. Thus, for all hardness cases above, this running time is essentially optimal under ETH.

Authors: Arnaud Casteigts, Hendrik Molter, Meirav Zehavi

Temporal graphs have edge sets that change over discrete time steps. Such graphs are temporally connected (TC) if all pairs of vertices can reach each other using paths that traverse the edges in a time-respecting way (temporal paths). Given a TC temporal graph it, a natural question is to find a minimum spanning subgraph of it that preserves temporal connectivity. These structures, known as temporal spanners, are fundamental and their properties (especially size) have been studied thoroughly in the past decade. In particular, the problem of minimizing the size of a temporal spanner is known to be hard. However, the existing results establish hardness for several incomparable settings and versions of the problem. In this article, we unify and strengthen these results by showing that this problem is NP-hard even on temporal graphs that are simple and proper (also known as "happy"), i.e., where every edge appears only one time, and a vertex cannot be incident to several edges simultaneously. Proving hardness in this extremely restricted setting implies, at once, that the problem is NP-hard for all the previously considered settings and versions of the problem, resolving Open Question 4 in [Casteigts et al. TCS, 2024]. We also initiate the parameterized study of this problem, showing that in the happy setting, the problem can be solved in polynomial time if the underlying graph has a constant-size vertex cover, this result being actually the first positive result on temporal spanners in general. We also show that in the non-happy setting, the problem is W[1]-hard when parameterized by the feedback vertex number of the underlying graph.

Authors: Ivor van der Hoog, John Iacono, Eva Rotenberg, Daniel Rutschmann

A heap is a dynamic data structure that stores a set of labeled values under the following operations: pop returns the minimum value of the heap, Push($x_i$) pushes a new value $x_i$ onto the heap, and DecreaseKey($i$, $v$) decreases the value $x_i$ to $v$. A working-set heap is a heap that supports the $x_i \gets$ pop$()$ operation in $O(\log Γ(x_i) )$ time where $Γ(x_i)$ is the size of the \emph{working set}: the number of elements that were pushed onto the heap while $x_i$ was in the heap. The goal of working set heap design is to maintain the working set property while minimizing the overhead of the Push and DecreaseKey operations. On a word RAM, there exist working set heaps that support Push and DecreaseKey in amortized constant time. In this paper, we show via a simple construction that pointer machines, one of the most general and least-assuming computational models, support working set heaps that support Push in amortized constant time and DecreaseKey in inverse-Ackermann time. A by-product of this analysis is that Dijkstra's shortest path algorithm can be near-universally optimal on a pointer machine -- incurring only an additive $O(m \, α(m))$ overhead compared to the optimal running time for distance ordering, where $m$ denotes the number of edges in the graph.

Authors: Jean Cardinal, Kevin Mann, Akira Suzuki, Takahiro Suzuki, Yuma Tamura, Xiao Zhou

We initiate the study of the shortest reconfiguration problem for independent sets under the adjacency relation derived from the independent set polytope. Given a graph and two independent sets, the problem asks for a shortest sequence transforming one into the other such that the subgraph induced by the symmetric difference of any two consecutive sets is connected. This is equivalent to finding a shortest path on the $1$-skeleton of the independent set polytope. We prove that the problem is NP-hard even on planar graphs of bounded degree, as well as on split graphs. Notably, the hardness for planar graphs of bounded degree still holds even when deciding whether the target can be reached in at most two steps. For split graphs, we further show the W[2]-hardness when parameterized by the number of steps, as well as the inapproximability of the optimal length. As a consequence, we prove that the length of a shortest path between two vertices of a 0/1 polytope in $\mathbb{R}^n$ described by $O(n)$ linear inequalities is hard to approximate within a factor of $(1-\varepsilon)\ln n$ for any constant $ε>0$, unless $P=NP$. On the positive side, we provide polynomial-time algorithms for block graphs, cographs, and bipartite chain graphs. Moreover, for paths and cycles, we show that the optimal length of the shortest reconfiguration sequence exactly matches a trivial upper bound.

Authors: Yuda Feng, Weijiang Hu, Shi Li

We propose a new convex programming relaxation for the weighted Nash social welfare (NSW) problem that achieves a matching $(e^{1/e}\approx 1.445)$-approximation via the rounding algorithm of Feng and Li. Unlike the exponential-size configuration LP used in prior work, our formulation can be converted into a compact linear program of polynomial size, incurring only an additive loss of $\ln(1+ε)$ in the objective. This allows the program to be solved directly using standard LP solvers, without the ellipsoid method or dual separation oracles. In the unweighted case, we show that our convex program is equivalent to the restricted-spending Fisher market convex program of Cole and Gkatzelis, yielding a constructive proof that its integrality gap is exactly $e^{1/e}$. With a minor modification, our analysis also gives a simple proof of the $e^{1/e}$ EF1 gap for the identical agent setting. Finally, we show that our convex programming technique extends to two unrelated machine scheduling problems, recovering the best-known approximation ratios with simpler analyses.

Authors: Takaaki Nishimoto, Yasuo Tabei

A compressed self-index stores a string in compressed form while supporting locate queries without decompression. For highly repetitive strings (arising in web crawls, versioned documents, and genomic collections), static self-indexes can match the $δ$-optimal lower bound of $Ω(δ\log(n \log σ/ (δ\log n)) \log n)$ bits up to constant factors, where $n$ is the string length, $σ$ is the alphabet size, and $δ$ is the substring complexity. Their dynamic counterparts, however, remain scarce: every existing dynamic self-index either fails to attain $δ$-optimal space, pays at least $Θ(\log n)$ time per reported occurrence during locate, or exposes the longest common prefix (LCP) of the text inside its update time. We present the dynamic RR-index, a dynamic grammar-compressed self-index built on the restricted recompression run-length straight-line program (RLSLP). To our knowledge, it is the first dynamic self-index to attain $δ$-optimal space. The index occupies expected $O(δ\log(n \log σ/ (δ\log n)) \log n)$ bits, answers locate queries in expected $O(m + \log m \log^{2} n + \mathit{occ} (\log n / \log \log n))$ time (where $m$ is the pattern length and $\mathit{occ}$ is the number of occurrences), and supports insertions and deletions of a length-$m'$ substring in expected amortized $O(m' \log^{2} n + \log^{3} n)$ time, with no dependence on the LCP. On eleven highly repetitive corpora, including a $37$ GB Wikipedia dump and a $59$ GB human-chromosome collection, the dynamic RR-index is up to $77\times$ faster than the dynamic r-index on updates and up to $11\times$ faster than other dynamic indexes on locate.

Authors: Andrew Au

We prove that any algorithm for detecting cycles in an $m \times n$ grid graph, where cells are colored and adjacency is defined by matching colors, must read all $mn$ cells in the worst case for all grids with $m \geq 2$ and $n \geq 2$. The proof is by adversary argument: we construct an adaptive adversary that maintains ambiguity -- one completion containing a cycle and one without -- until the final cell is read. The construction proceeds by tiling the grid with $2 \times 2$, $2 \times 3$, $3 \times 2$, and $3 \times 3$ blocks, each equipped with an independent block adversary, composed via a checkerboard isolation scheme.

Authors: Ryuki Tsukuba, Kazutoshi Ando

Hierarchical clustering is a fundamental task in data analysis, yet for a long time it lacked a principled objective function. Dasgupta [STOC 2016] initiated a formal framework by introducing a discrete objective function for cluster trees. This framework was subsequently expanded by Cohen-Addad et al. [J. ACM 2019], who introduced the notion of admissibility -- a criterion ensuring that, whenever the input similarities admit consistent hierarchical representations, the minimizers of an objective function recover them. They also provided a necessary and sufficient condition for admissibility within a broad class of objective functions, which we refer to as sum-type objective functions. Our contributions are twofold. First, we characterize admissible sum-type objective functions when the scaling function g is a symmetric polynomial of degree at most two, together with sufficient conditions in the degree-three case. For admissible objective functions in this class, we show that the recursive sparsest cut algorithm achieves an O($φ$)-approximation ratio, where $φ$ denotes the approximation factor of the sparsest cut subroutine. Second, we introduce a new class of objective functions for hierarchical clustering, which we term max-type objective functions, where cluster interactions are measured by maximum rather than aggregate similarity. For this class, we establish a general characterization of admissibility for arbitrary scaling functions g, and a complete characterization when g is a symmetric polynomial of degree at most two. These results provide new theoretical insights into admissible objective functions for hierarchical clustering and clarify the scope of algorithmic guarantees for optimizing them.

Authors: Pradipta Mitra

We propose a simple, projection-based algorithm for clustering mixtures of discrete (Bernoulli) distributions. Unlike previous approaches that rely on coordinate-specific ``combinatorial projections,'' our algorithm is rotationally invariant and works by projecting samples onto approximate centers obtained via a $k$-means computation on the best rank-$k$ approximation of the data matrix. This resolves a conjecture of McSherry on the existence of such geometric algorithms for discrete distributions. The same algorithm also applies to continuous distributions such as high-dimensional Gaussians, providing a unified approach across distribution types. We prove that the algorithm succeeds under a natural separation condition on the cluster centers.

Authors: Marin Bougeret, Guilherme C. M. Gomes, Ignasi Sau

Enumerative kernelization is a recent promising at the intersection of parameterized complexity and enumeration algorithms, with two proposed models. The first, known as enum-kernels and due to Creignou et al., was too permissive, leading to constant-sized kernels for every problem solvable with FPT-delay. To remedy this, Golovach et al. proposed the polynomial-delay enumeration kernelization model that, while addressing the shortcoming of the previous one, appears to be too strict, which we believe is a central reason for the slow development of the area. In this paper, we propose a new model for enumeration kernels, which we have called polynomial-delay (PD) kernels. It is more flexible than Golovach et al.'s kernels while still preserving their qualities; informally, it allows us to ignore ``bad'' solutions of the compressed instance when producing the solution set of the input instance, but still requires that the ``good'' solutions are lifted with polynomial-delay. After discussing the main properties of our model, we design a generic framework for vertex-subset problems to adapt decision kernels into PD kernels of the same size. We showcase our model's versatility and the framework's expressive power on the \textsc{Enum Vertex Cover} problem, where we want to list all vertex covers of size at most $k$ of a given graph. We generalize the kernelization dichotomy by Bougeret et al. about the existence of polynomial kernels for \textsc{Vertex Cover} parameterized by the vertex deletion distance to a minor-closed graph class, as well as by the solution size or feedback vertex number. The second one, in particular, is significantly simpler than the known kernel, requiring only a few lines for its lifting algorithm. Beyond our framework, we also show how to generalize to the enumeration setting the kernel of Bougeret et al. for the vertex-deletion distance to $c$-treedepth.

Authors: Yu Cong, Kangyi Tian

Motivated by the FPTAS for connectivity interdiction of Huang et al. (IPCO'24), we isolate the part of the argument that does not use cuts. The setting is a minimization problem over a feasible-set family $\mathcal F$ with a linear objective $w(S)=\sum_{e\in S}w(e)$. After dualizing the interdiction budget, deletion can be absorbed into truncated weights $w_λ(e)=\min\{w(e),λc(e)\}$. At an optimal Lagrange multiplier $λ^*$, the unknown optimal interdiction witness is a strict $2$-approximate minimizer of the reweighted problem. Thus an exact algorithm can be obtained whenever one can optimize $w_{λ^*}$ over $\mathcal F$, enumerate all its $2$-approximate minimizers, and solve the remaining knapsack problem.

Authors: Shabarish Chenakkod, Michał Dereziński, Xiaoyu Dong, Mark Rudelson

Perturbing a deterministic $n$-dimensional matrix with small Gaussian noise is a cornerstone of smoothed analysis of algorithms [Spielman and Teng, JACM 2004], as it reduces the condition number of the input to $O(n)$, and with it the complexity of many matrix algorithms. However, when deployed algorithmically, these perturbations are expensive due to the cost of generating and storing $n^2$ Gaussian random variables. We propose a perturbation that requires generating and storing $O(n)$ random numbers in $O(\log n)$ bits of precision, and reduces the condition number of any deterministic matrix to $O(n)$, matching Gaussian perturbations. Our result in particular implies a better complexity for the perturbed conjugate gradient algorithm, showing that we can solve an $n\times n$ linear system in linear space to within an arbitrarily small constant backward error using $O(n)$ matrix-vector products. In our construction, we introduce the concept of a pattern matrix, which is a dense deterministic matrix that maps all sparse vectors into dense vectors, and we combine it with a sparse perturbation whose entries are dependent and located in a non-uniform fashion. In order to analyze this construction, we develop new techniques for lower bounding the smallest singular value of a random matrix with dependent entries.

Authors: Takumi Kano, Yutaro Yamaguchi

We present a deterministic linear-time algorithm for finding an odd cycle through two specified vertices in an undirected graph. This is shown in a generalized form as follows: Let $Γ$ be any group in which every element is of order at most $2$. For a given $Γ$-labeled graph with two specified vertices (or edges), we can determine in linear time whether there exist two cycles with distinct labels that are through both of the two specified vertices (or edges), and find such cycles if yes.

Authors: Ryo Suzuki, Yutaro Yamaguchi

In the sliding window model, we are required to maintain the target statistics over the most recent $n$ elements of a data stream, which is captured by a window of size $n$ sliding over the data stream. Exact computation usually requires space linear in $n$, and the central goal is approximate maintenance using sublinear space. In this paper, we study the problem of maintaining the maximum subarray sum in the sliding window model. While the classical Kadane's algorithm computes the exact answer using constant space in the static setting, it does not extend directly, because a new element makes the oldest one expire, which may invalidate the optimal subarray so far. Our first observation is that the so-called Smooth Histogram framework can lead to a constant-factor approximation (in the sense of relative error) using $O((\log n)^2)$ bits of space. We then refine this framework accordingly, which enables for any $ε> 0$ to maintain a $(1 \pm ε)$-approximation using $O(ε^{-1}(\log n)^2)$ bits of space and $O(ε^{-1}\log n)$ operations per update. The space complexity is asymptotically optimal.

Authors: Saswata Jana, Partha Sarathi Mandal

Collaboration between drones and trucks in a last-mile delivery system offers numerous benefits and reduces many challenges of the traditional delivery system. Here, we introduce Drone-Delivery Packing Problem, where a set of parcels, associated with delivery intervals and cost, should be delivered to customer locations. The system comprises a set of identical drones and battery stations along truck's route, where drones swap depleted batteries or recharge them. The objective is to find assignment for all parcels by using the minimum number of drones, subject to the battery budget and compatibility of each drone's assignment. We consider three variants of the problem, based on conflicting characteristics and existence of battery service stations. All are NP-hard, and we have proposed approximation algorithms for each. When there are no battery stations, we propose a constant factor approximation algorithm using first fit decreasing bin packing algorithm. When the intervals are non-conflicting, we design a $(2+ ψ)$-approximation algorithm. In the presence of both battery stations and conflicting intervals, we present a $(4+ψ)$-approximation algorithm. The algorithm is later modified into a $(3+ψ)$-approximation algorithm when the battery service stations act as swapping stations. Here $ψ$ is a function of battery budget, minimum and maximum cost of the deliveries. Finally, we validate our results and compare the performance with the optimum on different instances.

I’ve been playing with some ideas for a cover for my book, and I ended up making an animation about P vs. NP. It’s on my homepage (I can’t embed javascript here). Click on a nail and see what happens; you can also move the chain to create other configurations. I was looking for something which was connected to the math in the book, and also visually appealing (?), and also related to the grand challenges in complexity theory, and on top of all of this something related to the (somewhat unorthodox) viewpoints expressed in the book. Any comment or other suggestions for the book cover (or the book itself) always welcome!

By Manu

I wanted to give a quick rundown of some upcoming Irrational Decision events, as I’ve managed to stack four of them into a week.

On Wednesday, April 29, I’m visiting the University of Wisconsin-Madison to give the SILO seminar. It’s at 12:30 in the Orchard View Room of the Wisconsin Institute for Discovery building. Rob Nowak and I started this multidisciplinary seminar on systems, information, learning, and optimization fifteen years ago, and I’m super happy that it’s still going strong. It’s fitting that I’m going to be giving a talk about the roots of the SILO subjects, when they were all considered disciplinary, not multidisciplinary. Do come by if you’re on campus.

On Friday, May 1, I’ll be at the University of Chicago, giving a lecture at the Data Science Institute at noon. I always love visiting Chicago and am looking forward to seeing the new data science building, which was a Lutheran seminary when I was an undergraduate there. Given my book’s framing, that’s quite a fitting, unintentional allegory.

On Tuesday, May 5, I’ll be participating in a conversation on “AI, rationality, and violence” with Kevin Baker, Sophia Goodfriend, and moderator Lily Hu. This is a free, online event hosted by The Boston Review at 3 PM Eastern Time. We’ll be discussing the “nature and meaning of rationality, how new technology is interfacing with old institutions, what popular AI discourses get wrong, and the consequences for politics, war, and social life in general.” I can’t wait to hash it out with three super brilliant people.

And finally, I’ll also be giving a talk about The Irrational Decision at 4 PM on May 5 at Berkeley. This presentation will be in conversation with Marion Fourcade and hosted by the Social Science Matrix and the BESI Technology Network. I’m looking forward to discussing the book with my on-campus colleagues there, as a way to celebrate the end of the semester. Details here.

Since I’ll be on the road, I expect blogging will be light for the next week. In transit, I’ll be writing down some thoughts for the summer session that I’ll probably post next week. Stay tuned!

Subscribe now

By Ben Recht

In a previous post we introduced strong chain quality (SCQ), which provides a strong form of censorship resistance: honest parties’ transactions are included in proportion to their share of the validator set in every block. This post considers three additional properties needed for efficient on-chain markets: hiding, simultaneous binding (SB), and accountable last look (ALL). Hiding Hiding: No information about the contents of honest parties’ inputs is revealed to the...

By Ittai Abraham, Pranav Garimidi, and Joachim Neu

Authors: Demian Banakh, Katzper Michno

We develop an analytical framework for Boolean Promise Constraint Satisfaction Problems (PCSPs) that studies polymorphisms through the notion of influence from Fourier analysis of Boolean functions. Extending the work of Brakensiek, Guruswami, and Sandeep [ICALP'21] on Ordered PCSPs, we identify two general phenomena in Boolean minions indicative of hardness or tractability: (1) preservation of coordinate influence under random 2-to-1 minors and (2) the presence of sharp thresholds. We demonstrate that these phenomena occur in broader settings than previously established, yielding new hardness/tractability results for minions consisting of unate or polynomial threshold functions.

Authors: Shuai Zeng

Joint measurements on multiple copies of a quantum state provide access to nonlinear observables such as $\operatorname{tr}(ρ^t)$, but whether replica number marks a sharp information-theoretic resource boundary has remained unclear. For every fixed order $t\ge 3$, existing protocols show that $\lceil t/2\rceil$ replicas already suffice for polynomial-sample estimation of $\operatorname{tr}(ρ^t)$, yet it has remained open whether one fewer replica must necessarily incur a sample-complexity barrier growing with the dimension. We prove that this is indeed the case in the sample/copy-access model with replica-limited joint measurements: any protocol restricted to $\lceil t/2\rceil-1$ replicas requires dimension-growing sample complexity, while $\lceil t/2\rceil$ replicas suffice by prior work. Thus the exact replica threshold for fixed-order pure moments is $\lceil t/2\rceil$. Equivalently, for fixed-order pure moments, one additional coherent replica is not merely useful but marks the exact threshold between polynomial-sample estimation and a dimension-growing regime in the replica-limited model. We further show that the same threshold law extends to a broad family of observable-weighted moments $\operatorname{tr}(Oρ^t)$, including Pauli observables and other observables with bounded operator norm and macroscopic trace norm. Coherent replica number therefore acts as a genuinely discrete resource for nonlinear quantum-state estimation.

Authors: Samir Datta, Asif Khan, Felix Tschirbs, Nils Vortmeier, Thomas Zeume

Consider two planar graphs which are subject to edge insertions and deletions. We show that whether the two graphs are isomorphic can be maintained with first-order logic formulas and auxiliary data of polynomial size. This places the dynamic planar graph isomorphism problem into the dynamic descriptive complexity class DynFO. As a consequence, there is a dynamic constant-time parallel algorithm with polynomial-size auxiliary data which maintains whether two dynamic planar graphs are isomorphic.

Authors: Ran Raz

We prove a lower bound of $Ω\left(n^{1.5}\right)$ for the number of product gates in non-commutative arithmetic circuits for an explicit $n$-variate degree-$n$ polynomial $f_{n}$ (over every field). We observe that this implies that over certain non-commutative rings $R$, any arithmetic circuit that computes the induced polynomial function $f_{n}: R^n \rightarrow R$, using the ring operations of addition and multiplication in $R$, requires at least $Ω\left(n^{1.5}\right)$ multiplications. More generally, for any $d\geq 2$ and sufficiently large $n$, we obtain a lower bound of $Ω\left(d\sqrt{n}\right)$ for $n$-variate degree-$d$ polynomials, for both these models. Prior to our work, the only known lower bounds for the size of non-commutative circuits, or for the size of arithmetic circuits over any ring, were slightly super-linear in $\max\{n,d\}$: $Ω\left(n\log d\right)$ by Baur and Strassen, and $Ω\left(d\log n\right)$ by Nisan. (Nisan's bound was proved for non-commutative arithmetic circuits and implies a bound for arithmetic circuits over non-commutative rings by our observation).

Authors: Dmitry Babichev, Sergey Babichev

We study the exact counting problem for all lattice rectangles contained in the square $[0,n)\times[0,n)$, including non-axis-parallel ones. Starting from the standard parametrization by a primitive direction $(u,v)$ and two side lengths, we derive a sequence of exact algorithms of complexity $O(n^2)$, $O(n^{3/2}\log n)$, $O(n^{4/3}\log n)$, and finally $O(n\log^3 n)$. The main idea behind the near-linear algorithm is to reduce the geometric summation to a constant-size family of weighted floor sums closed under Euclidean-style affine and reciprocal transformations, and hence evaluable in $O(\log n)$ time per query. Besides the exact algorithmic result, we also derive a two-term asymptotic expansion, $F(n)=\frac{4\log 2-1}{π^2}n^4\log n+B\,n^4+o(n^4)$ with the explicit formula for $B$, which provides an independent consistency check for the large-$n$ numerical data produced by the algorithms.

Authors: Cheng Jiang, Yinchen Liu, Huacheng Yu

A fundamental question in streaming complexity is whether every space-efficient turnstile algorithm is implicitly a linear sketch. The landmark work of Li, Nguyen, and Woodruff [LNW14] established an equivalence between the two, but their reduction requires a stream length that is at least doubly exponential in the dimension $n$. In the opposite direction, results by Kallaugher and Price [KP20] demonstrate a separation for streams of linear length, showing that the equivalence does not hold in general. The most natural and practically relevant regime -- polynomial-length streams -- has therefore remained open. We show that polynomial-length turnstile algorithms admit linear-sketch simulations. More precisely, if a turnstile algorithm uses $S$ bits of space and succeeds on all streams of length $\mathrm{poly}(D, n)$, then on final vectors $x$ with $\|x\|_2 \le D$, its output can be recovered from $O(S)$ linear measurements of $x$, using $O(S \log S)$ bits overall. For smooth problems under appropriate input distributions, a mollified version of the reduction yields a bounded-entry sketch with $O(S / \log D)$ measurements and optimal $O(S)$ total space. Our results extend to strict turnstile streams and non-uniform Read-Once Branching Programs (ROBPs). Our proof departs from prior transition-graph based machinery, relying instead on a Fourier-analytic framework and tools from additive combinatorics to extract discrete linear measurements. Our analysis shows that any $S$-bit algorithm can only be sensitive to a low-dimensional lattice of heavy Fourier frequencies, which we then use to construct the rows of the sketching matrix. Consequently, we obtain new lower bounds for polynomial-length streams via existing real sketching and communication lower bounds.

Authors: Matthias Lanzinger

Submodular width is a central structural measure governing the complexity of conjunctive query evaluation. In this paper we recast submodular width in geometric terms. We how that submodular width can be approximated, up to a factor $3/2$, by a new branchwidth parameter defined in terms of edge separations in the hypergraph and the costs induced on them by admissible submodular functions. This reformulation turns lower bounds on submodular width into the problem of constructing well-balanced edge separations whose induced cost remains small. We then express this connection through a variational characterisation in terms of a convex body. Using these tools, we relate submodular width to more familiar graph-theoretic notions, including line-graph treewidth and multicommodity flow, and obtain general conditions under which submodular width is tightly linked to generalised hypertree width. In particular, under various natural conditions we show that \[ subw(H) \in Ω\left(\frac{ghw(H)}{\log ghw(H)} \right). \]

A few months ago in Oxford, Bernard Sufrin, an emeritus fellow, said he's looking to hire a student to implement LEAP (Logic Engine for Argument by Pointing), a way to teach logic by proving basic logic theorems via pointing and clicking. Rahul Santhanam said why not give it to AI. Bernard said AI can't handle this task. I thought why not give it a try.

I gave Claude a single prompt that Bernard helped me formulate:

Architecture of a system to support proof by pointing in first order logic using LEAP

About an hour later, without giving additional details, we had a working prototype. Give it a try. I put the code and some more details on GitHub.

Watching Claude work was amazing. Claude created an architecture based on the paper Proof by Pointing by Yves Bertot, Gilles Kahn and Laurent Théry.

Claude then asked me:

Would you like me to proceed with implementing any of these layers?

Why not? So I told Claude to go ahead.

It started coding and it created 78 test cases and kept debugging itself until all those test cases worked out. It took me longer to get the program working on the web than Claude took to program it. I sent the link to Bernard who responded "Wow! I take it back if the program was all synthesized from the prompt." 

When I asked Bernard a month later if I could post about this program, he agreed, though he had some additional comments.

The consolation for me is that the outcome, though surprising and I suppose delightful (though it didn't manage rules for quantifiers), didn't refute my conjecture that Claude et al cannot do "architecture". The architecture (MVC) is stock; the "proof by pointing" hint led it to a paper of the same name which gave details of how to derive terms/formulae/goals in the (unfinished) proof from screen coordinates. Maybe you could give a substantively different prompt.

It may be of interest to know that the Bornat/Sufrin JAPE program, still on GitHub, was eventually a lot more ambitious when it came to selecting things: terms, subterms, goals. But it took more than 2 hours to build!

Bernard has a point. It wasn't just the fifteen-word prompt alone. Claude leaned on the Bertot et al. paper to guide its design and implementation. Still, that Claude did architect, build and debug the system from the prompt and the paper is truly impressive. We've truly crossed a threshold for coding, far beyond what would have been possible just a few months earlier.

By Lance Fortnow

Tendermint and Simplex are both leader-based BFT protocols for partial synchrony with optimal resilience and $3\delta$ good-case latency. There is a subtle tradeoff between them: In the optimistic responsive model, Simplex obtains a worst-case view latency of $3\Delta+\delta$ while Tendermint obtains a worst-case view latency of $4\Delta+\delta$. On the other hand, Tendermint requires only a bounded number of certificates to make progress in each view, while in Simplex the number...

By Ittai Abraham

June 29 – July 3, 2026 San Diego, USA https://learningtheory.org/colt2026/workshops.html#cfp Submission deadline: May 7, 2026 The Conference on Learning Theory (COLT 2026) will dedicate the first day of the main conference program (June 29 – July 3) to contributed and invited workshops, tutorials, and community events (e.g., affinity workshops, mentoring activities, socials). We invite proposals … Continue reading Workshops, Tutorials, and Community Events at COLT 2026

By shacharlovett

Authors: Piotr Kawałek, Jacek Krzaczkowski

Most classical results in circuit complexity theory concern circuits over the Boolean domain. Besides their simplicity and the ease of comparing different languages, the actual architecture of computers is also an important motivating factor. On the other hand, by restricting attention to Boolean circuits, we lose sight of the much richer landscape of circuits over larger domains. Our goal is to bridge these two worlds: to use deep algebraic tools to obtain results in computational complexity theory, including circuit complexity, and to apply results from computational complexity to gain a better understanding of the structure of finite algebras. In this paper, we propose a unifying algebraic framework which we believe will help achieve this goal. Our work is inspired by branching programs and nonuniform deterministic automata introduced by Barrington, as well as by their generalization proposed by Idziak et al. We begin our investigation by studying the languages recognized by natural classes of algebraic structures. In particular, we characterize language classes recognized by circuits over simple algebras and over algebras from congruence modular varieties.