Theory of Computing Report

Authors: Srinivasan Arunachalam, Arkopal Dutt

We consider the task of learning a structured stabilizer decomposition of an arbitrary $n$-qubit quantum state $|\psi\rangle$: for $\varepsilon > 0$, output a state $|\phi\rangle$ with stabilizer-rank $\textsf{poly}(1/\varepsilon)$ such that $|\psi\rangle=|\phi\rangle+|\phi'\rangle$ where $|\phi'\rangle$ has stabilizer fidelity $< \varepsilon$. We firstly show the existence of such decompositions using the recently established inverse theorem for the Gowers-$3$ norm of states [AD,STOC'25]. To learn this structure, we initiate the task of self-correction of a state $|\psi\rangle$ with respect to a class of states $\textsf{C}$: given copies of $|\psi\rangle$ which has fidelity $\geq \tau$ with a state in $\textsf{C}$, output $|\phi\rangle \in \textsf{C}$ with fidelity $|\langle \phi | \psi \rangle|^2 \geq \tau^C$ for a constant $C>1$. Assuming the algorithmic polynomial Frieman-Rusza (APFR) conjecture (whose combinatorial version was recently resolved [GGMT,Annals of Math.'25], we give a polynomial-time algorithm for self-correction of stabilizer states. Given access to the state preparation unitary $U_\psi$ for $|\psi\rangle$ and its controlled version $cU_\psi$, we give a polynomial-time protocol that learns a structured decomposition of $|\psi\rangle$. Without assuming APFR, we give a quasipolynomial-time protocol for the same task. As our main application, we give learning algorithms for states $|\psi\rangle$ promised to have stabilizer extent $\xi$, given access to $U_\psi$ and $cU_\psi$. We give a protocol that outputs $|\phi\rangle$ which is constant-close to $|\psi\rangle$ in time $\textsf{poly}(n,\xi^{\log \xi})$, which can be improved to polynomial-time assuming APFR. This gives an unconditional learning algorithm for stabilizer-rank $k$ states in time $\textsf{poly}(n,k^{k^2})$. As far as we know, learning arbitrary states with even stabilizer-rank $k \geq 2$ was unknown.

Authors: Abhimanyu Choudhury, Meena Mahajan

Quantified Conflict Driven Clause Leaning (QCDCL) is one of the main approaches to solving Quantified Boolean Formulas (QBF). Cube-learning is employed in this approach to ensure that true formulas can be verified. Dependency Schemes help to detect spurious dependencies that are implied by the variable ordering in the quantifier prefix of QBFs but are not essential for constructing (counter)models. This detection can provably shorten refutations in specific proof systems, and is expected to speed up runs of QBF solvers. The simplest underlying proof system [BeyersdorffB\"ohm-LMCS2023], formalises the reasoning in the QCDCL approach on false formulas, when neither cube learning nor dependency schemes is used. The work of [B\"ohmPeitlBeyersdorff-AI2024] further incorporates cube-learning. The work of [ChoudhuryMahajan-JAR2024] incorporates a limited use of dependency schemes, but without cube-learning. In this work, proof systems underlying the reasoning of QCDCL solvers which use cube learning, and which use dependency schemes at all stages, are formalised. Sufficient conditions for soundness and completeness are presented, and it is shown that using the standard and reflexive resolution path dependency schemes ($D^{std}$ and $D^{rrs}$) to relax the decision order provably shortens refutations. When the decisions are restricted to follow quantification order, but dependency schemes are used in propagation and learning, in conjunction with cube-learning, the resulting proof systems using the dependency schemes $D^{std}$ and $D^{rrs}$ are investigated in detail and their relative strengths are analysed.

Authors: Yang Cao, Zhao Song, Jiahao Zhang, Jiale Zhao

Graph neural networks (GNNs) have become a core paradigm for learning on relational data. In materials science, equivariant GNNs (EGNNs) have emerged as a compelling backbone for crystalline-structure prediction, owing to their ability to respect Euclidean symmetries and periodic boundary conditions. Despite strong empirical performance, their expressive power in periodic, symmetry-constrained settings remains poorly understood. This work characterizes the intrinsic computational and expressive limits of EGNNs for crystalline-structure prediction through a circuit-complexity lens. We analyze the computations carried out by EGNN layers acting on node features, atomic coordinates, and lattice matrices, and prove that, under polynomial precision, embedding width $d=O(n)$ for $n$ nodes, $O(1)$ layers, and $O(1)$-depth, $O(n)$-width MLP instantiations of the message/update/readout maps, these models admit a simulation by a uniform $\mathsf{TC}^0$ threshold-circuit family of polynomial size (with an explicit constant-depth bound). Situating EGNNs within $\mathsf{TC}^0$ provides a concrete ceiling on the decision and prediction problems solvable by such architectures under realistic resource constraints and clarifies which architectural modifications (e.g., increased depth, richer geometric primitives, or wider layers) are required to transcend this regime. The analysis complements Weisfeiler-Lehman style results that do not directly transfer to periodic crystals, and offers a complexity-theoretic foundation for symmetry-aware graph learning on crystalline systems.

Authors: Abhinav Deshpande, Bill Fefferman, Soumik Ghosh, Michael Gullans, Dominik Hangleiter

A key issue of current quantum advantage experiments is that their verification requires a full classical simulation of the ideal computation. This limits the regime in which the experiments can be verified to precisely the regime in which they are also simulatable. An important outstanding question is therefore to find quantum advantage schemes that are also classically verifiable. We make progress on this question by designing a new quantum advantage proposal--Hidden Code Sampling--whose output distribution is conditionally peaked. These peaks enable verification in far less time than it takes for full simulation. At the same time, we show that exactly sampling from the output distribution is classically hard unless the polynomial hierarchy collapses, and we propose a plausible conjecture regarding average-case hardness. Our scheme is based on ideas from quantum error correction. The required quantum computations are closely related to quantum fault-tolerant circuits and can potentially be implemented transversally. Our proposal may thus give rise to a next generation of quantum advantage experiments en route to full quantum fault tolerance.

Authors: Mishal Assif P K, Yuliy Baryshnikov

A function on a topological space is called unimodal if all of its super-level sets are contractible. A minimal unimodal decomposition of a function $f$ is the smallest number of unimodal functions that sum up to $f$. The problem of decomposing a given density function into its minimal unimodal components is fundamental in topological statistics. We show that finding a minimal unimodal decomposition of an edge-linear function on a graph is NP-hard. Given any $k \geq 2$, we establish the NP-hardness of finding a unimodal decomposition consisting of $k$ unimodal functions. We also extend the NP-hardness result to related variants of the problem, including restriction to planar graphs, inapproximability results, and generalizations to higher dimensions.

Authors: Mikkel Abrahamsen, Sujoy Bhore, Maike Buchin, Jacobus Conradi, Ce Jin, André Nusser, Carolin Rehs

A fundamental problem in shape matching and geometric similarity is computing the maximum area overlap between two polygons under translation. For general simple polygons, the best-known algorithm runs in $O((nm)^2 \log(nm))$ time [Mount, Silverman, Wu 96], where $n$ and $m$ are the complexities of the input polygons. In a recent breakthrough, Chan and Hair gave a linear-time algorithm for the special case when both polygons are convex. A key challenge in computational geometry is to design improved algorithms for other natural classes of polygons. We address this by presenting an $O((nm)^{3/2} \log(nm))$-time algorithm for the case when both polygons are orthogonal. This is the first algorithm for polygon overlap on orthogonal polygons that is faster than the almost 30 years old algorithm for simple polygons. Complementing our algorithmic contribution, we provide $k$-SUM lower bounds for problems on simple polygons with only orthogonal and diagonal edges. First, we establish that there is no algorithm for polygon overlap with running time $O(\max(n^2,nm^2)^{1-\varepsilon})$, where $m\leq n$, unless the $k$-SUM hypothesis fails. This matches the running time of our algorithm when $n=m$. We use part of the above construction to also show a lower bound for the polygon containment problem, a popular special case of the overlap problem. Concretely, there is no algorithm for polygon containment with running time $O(n^{2-\varepsilon})$ under the $3$-SUM hypothesis, even when the polygon to be contained has $m=O(1)$ vertices. Our lower bound shows that polygon containment for these types of polygons (i.e., with diagonal edges) is strictly harder than for orthogonal polygons, and also strengthens the previously known lower bounds for polygon containment. Furthermore, our lower bounds show tightness of the algorithm of [Mount, Silverman, Wu 96] when $m=O(1)$.

Authors: Sándor P. Fekete, Phillip Keldenich, Dominik Krupke, Michael Perk

We consider a class of optimization problems that are fundamental to testing in modern configurable software systems, e.g., in automotive industries. In pairwise interaction sampling, we are given a (potentially very large) configuration space, in which each dimension corresponds to a possible Boolean feature of a software system; valid configurations are the satisfying assignments of a given propositional formula $\varphi$. The objective is to find a minimum-sized family of configurations, such that each pair of features is jointly tested at least once. Due to its relevance in Software Engineering, this problem has been studied extensively for over 20 years. In addition to new theoretical insights (we prove BH-hardness), we provide a broad spectrum of key contributions on the practical side that allow substantial progress for the practical performance. Remarkably, we are able to solve the largest instances we found in published benchmark sets (with about 500000000 feasible interactions) to provable optimality. Previous approaches were not even able to compute feasible solutions.

Authors: Renato Ferreira Pinto Jr., Diptaksho Palit, Sofya Raskhodnikova

We initiate a systematic study of the computational complexity of property testing, focusing on the relationship between query and time complexity. While traditional work in property testing has emphasized query complexity, relatively little is known about the computational hardness of property testers. Our goal is to chart the landscape of time-query interplay and develop tools for proving time complexity lower bounds. Our first contribution is a pair of time-query hierarchy theorems for property testing. For all suitable nondecreasing functions $q(n)$ and $t(n)$ with $t(n)\geq q(n)$, we construct properties with query complexity $\tilde{\Theta}(q(n))$ and time complexity $\tilde\Omega(t(n))$. Our weak hierarchy holds unconditionally, whereas the strong version-assuming the Strong Exponential Time Hypothesis-provides better control over the time complexity of the constructed properties. We then turn to halfspaces in $\mathbb{R}^d$, a fundamental class in property testing and learning theory. We study the problem of approximating the distance from the input function to the nearest halfspace within additive error $\epsilon$. For the distribution-free distance approximation problem, known algorithms achieve query complexity $O(d/\epsilon^2)$, but take time $\tilde{\Theta}(1/\epsilon^d)$. We provide a fine-grained justification for this gap: assuming the $k$-SUM conjecture, any algorithm must have running time ${\Omega}(1/\epsilon^{d/2})$. This fine-grained lower bound yields a provable separation between query and time complexity for a natural and well-studied (tolerant) testing problem. We also prove that any Statistical Query (SQ) algorithm under the standard Gaussian distribution requires $(1/\epsilon)^{\Omega(d)}$ queries if the queries are answered with additive error up to $\epsilon^{\Omega(d)}$, revealing a fundamental barrier even in the distribution-specific setting.

Authors: Giacomo De Palma, Marco Fanizza, Connor Mowry, Ryan O'Donnell

We study hypothesis testing (aka state certification) in the non-identically distributed setting. A recent work (Garg et al. 2023) considered the classical case, in which one is given (independent) samples from $T$ unknown probability distributions $p_1, \dots, p_T$ on $[d] = \{1, 2, \dots, d\}$, and one wishes to accept/reject the hypothesis that their average $p_{\mathrm{avg}}$ equals a known hypothesis distribution $q$. Garg et al. showed that if one has just $c = 2$ samples from each $p_i$, and provided $T \gg \frac{\sqrt{d}}{\epsilon^2} + \frac{1}{\epsilon^4}$, one can (whp) distinguish $p_{\mathrm{avg}} = q$ from $d_{\mathrm{TV}}(p_{\mathrm{avg}},q) > \epsilon$. This nearly matches the optimal result for the classical iid setting (namely, $T \gg \frac{\sqrt{d}}{\epsilon^2}$). Besides optimally improving this result (and generalizing to tolerant testing with more stringent distance measures), we study the analogous problem of hypothesis testing for non-identical quantum states. Here we uncover an unexpected phenomenon: for any $d$-dimensional hypothesis state $\sigma$, and given just a single copy ($c = 1$) of each state $\rho_1, \dots, \rho_T$, one can distinguish $\rho_{\mathrm{avg}} = \sigma$ from $D_{\mathrm{tr}}(\rho_{\mathrm{avg}},\sigma) > \epsilon$ provided $T \gg d/\epsilon^2$. (Again, we generalize to tolerant testing with more stringent distance measures.) This matches the optimal result for the iid case, which is surprising because doing this with $c = 1$ is provably impossible in the classical case. We also show that the analogous phenomenon happens for the non-iid extension of identity testing between unknown states. A technical tool we introduce may be of independent interest: an Efron-Stein inequality, and more generally an Efron-Stein decomposition, in the quantum setting.

Authors: Binita Maity, Shrutimoy Das, Anirban Dasgupta

In this paper, we present a local search-based algorithm for individually fair clustering in the presence of outliers. We consider the individual fairness definition proposed in Jung et al., which requires that each of the $n$ points in the dataset must have one of the $k$ centers within its $n/k$ nearest neighbors. However, if the dataset is known to contain outliers, the set of fair centers obtained under this definition might be suboptimal for non-outlier points. In order to address this issue, we propose a method that discards a set of points marked as outliers and computes the set of fair centers for the remaining non-outlier points. Our method utilizes a randomized variant of local search, which makes it scalable to large datasets. We also provide an approximation guarantee of our method as well as a bound on the number of outliers discarded. Additionally, we demonstrate our claims experimentally on a set of real-world datasets.

Authors: Yashaswini Mathur, Prafullkumar Tale

We study the \textsc{Labeled Contractibility} problem, where the input consists of two vertex-labeled graphs $G$ and $H$, and the goal is to determine whether $H$ can be obtained from $G$ via a sequence of edge contractions. Lafond and Marchand~[WADS 2025] initiated the parameterized complexity study of this problem, showing it to be \(\W[1]\)-hard when parameterized by the number \(k\) of allowed contractions. They also proved that the problem is fixed-parameter tractable when parameterized by the tree-width \(\tw\) of \(G\), via an application of Courcelle's theorem resulting in a non-constructive algorithm. In this work, we present a constructive fixed-parameter algorithm for \textsc{Labeled Contractibility} with running time \(2^{\mathcal{O}(\tw^2)} \cdot |V(G)|^{\mathcal{O}(1)}\). We also prove that unless the Exponential Time Hypothesis (\ETH) fails, it does not admit an algorithm running in time \(2^{o(\tw^2)} \cdot |V(G)|^{\mathcal{O}(1)}\). This result adds \textsc{Labeled Contractibility} to a small list of problems that admit such a lower bound and matching algorithm. We further strengthen existing hardness results by showing that the problem remains \NP-complete even when both input graphs have bounded maximum degree. We also investigate parameterizations by \((k + \delta(G))\) where \(\delta(G)\) denotes the degeneracy of \(G\), and rule out the existence of subexponential-time algorithms. This answers question raised in Lafond and Marchand~[WADS 2025]. We additionally provide an improved \FPT\ algorithm with better dependence on \((k + \delta(G))\) than previously known. Finally, we analyze a brute-force algorithm for \textsc{Labeled Contractibility} with running time \(|V(H)|^{\mathcal{O}(|V(G)|)}\), and show that this running time is optimal under \ETH.

Authors: Binhong Li, Xiao Yan, Shangqi Lu

Approximate nearest neighbor (ANN) search in high-dimensional metric spaces is a fundamental problem with many applications. Over the past decade, proximity graph (PG)-based indexes have demonstrated superior empirical performance over alternatives. However, these methods often lack theoretical guarantees regarding the quality of query results, especially in the worst-case scenarios. In this paper, we introduce the {\alpha}-convergent graph ({\alpha}-CG), a new PG structure that employs a carefully designed edge pruning rule. This rule eliminates candidate neighbors for each data point p by applying the shifted-scaled triangle inequalities among p, its existing out-neighbors, and new candidates. If the distance between the query point q and its exact nearest neighbor v* is at most {\tau} for some constant {\tau} > 0, our {\alpha}-CG finds the exact nearest neighbor in poly-logarithmic time, assuming bounded intrinsic dimensionality for the dataset; otherwise, it can find an ANN in the same time. To enhance scalability, we develop the {\alpha}-convergent neighborhood graph ({\alpha}-CNG), a practical variant that applies the pruning rule locally within each point's neighbors. We also introduce optimizations to reduce the index construction time. Experimental results show that our {\alpha}-CNG outperforms existing PGs on real-world datasets. For most datasets, {\alpha}-CNG can reduce the number of distance computations and search steps by over 15% and 45%, respectively, when compared with the best-performing baseline.

Authors: Longkun Guo, Zeyu Lin, Chaoqi Jia, Chao Chen

Many real-world applications pose challenges in incorporating fairness constraints into the $k$-center clustering problem, where the dataset consists of $m$ demographic groups, each with a specified upper bound on the number of centers to ensure fairness. Focusing on big data scenarios, this paper addresses the problem in a streaming setting, where data points arrive one by one sequentially in a continuous stream. Leveraging a structure called the $\lambda$-independent center set, we propose a one-pass streaming algorithm that first computes a reserved set of points during the streaming process. Then, for the post-streaming process, we propose an approach for selecting centers from the reserved point set by analyzing all three possible cases, transforming the most complicated one into a specially constrained vertex cover problem in an auxiliary graph. Our algorithm achieves a tight approximation ratio of 5 while consuming $O(k\log n)$ memory. It can also be readily adapted to solve the offline fair $k$-center problem, achieving a 3-approximation ratio that matches the current state of the art. Furthermore, we extend our approach to a semi-structured data stream, where data points from each group arrive in batches. In this setting, we present a 3-approximation algorithm for $m = 2$ and a 4-approximation algorithm for general $m$. Lastly, we conduct extensive experiments to evaluate the performance of our approaches, demonstrating that they outperform existing baselines in both clustering cost and runtime efficiency.

Authors: Argyrios Deligkas, Michelle Döring, Eduard Eiben, Tiger-Lily Goldsmith, George Skretas, Georg Tennigkeit

We study the parameterized complexity of maximum temporal connected components (tccs) in temporal graphs, i.e., graphs that deterministically change over time. In a tcc, any pair of vertices must be able to reach each other via a time-respecting path. We consider both problems of maximum open tccs (openTCC), which allow temporal paths through vertices outside the component, and closed tccs (closedTCC) which require at least one temporal path entirely within the component for every pair. We focus on the structural parameter of treewidth, tw, and the recently introduced temporal parameter of temporal path number, tpn, which is the minimum number of paths needed to fully describe a temporal graph. We prove that these parameters on their own are not sufficient for fixed parameter tractability: both openTCC and closedTCC are NP-hard even when tw=9, and closedTCC is NP-hard when tpn=6. In contrast, we prove that openTCC is in XP when parameterized by tpn. On the positive side, we show that both problem become fixed parameter tractable under various combinations of structural and temporal parameters that include, tw plus tpn, tw plus the lifetime of the graph, and tw plus the maximum temporal degree.

Authors: Jianqiang Li

Given a matrix $A$ of dimension $M \times N$ and a vector $\vec{b}$, the quantum linear system (QLS) problem asks for the preparation of a quantum state $|\vec{y}\rangle$ proportional to the solution of $A\vec{y} = \vec{b}$. Existing QLS algorithms have runtimes that scale linearly with the condition number $\kappa(A)$, the sparsity of $A$, and logarithmically with inverse precision, but often overlook structural properties of $\vec{b}$, whose alignment with $A$'s eigenspaces can greatly affect performance. In this work, we present a new QLS algorithm that explicitly leverages the structure of the right-hand side vector $\vec{b}$. The runtime of our algorithm depends polynomially on the sparsity of the augmented matrix $H = [A, -\vec{b}]$, the inverse precision, the $\ell_2$ norm of the solution $\vec{y} = A^+ \vec{b}$, and a new instance-dependent parameter \[ ET= \sum_{i=1}^M p_i^2 \cdot d_i, \] where $\vec{p} = (AA^{\top})^+ \vec{b}$, and $d_i$ denotes the squared $\ell_2$ norm of the $i$-th row of $H$. We also introduce a structure-aware rescaling technique tailored to the solution $\vec{y} = A^+ \vec{b}$. Unlike left preconditioning methods, which transform the linear system to $DA\vec{y} = D\vec{b}$, our approach applies a right rescaling matrix, reformulating the linear system as $AD\vec{z} = \vec{b}$. As an application of our instance-aware QLS algorithm and new rescaling scheme, we develop a quantum algorithm for solving multivariate polynomial systems in regimes where prior QLS-based methods fail. This yields an end-to-end framework applicable to a broad class of problems. In particular, we apply it to the maximum independent set (MIS) problem, formulated as a special case of a polynomial system, and show through detailed analysis that, under certain conditions, our quantum algorithm for MIS runs in polynomial time.

Authors: Marco Fanizza, Vishnu Iyer, Junseo Lee, Antonio A. Mele, Francesco A. Mele

Bosonic Gaussian unitaries are fundamental building blocks of central continuous-variable quantum technologies such as quantum-optic interferometry and bosonic error-correction schemes. In this work, we present the first time-efficient algorithm for learning bosonic Gaussian unitaries with a rigorous analysis. Our algorithm produces an estimate of the unknown unitary that is accurate to small worst-case error, measured by the physically motivated energy-constrained diamond distance. Its runtime and query complexity scale polynomially with the number of modes, the inverse target accuracy, and natural energy parameters quantifying the allowed input energy and the unitary's output-energy growth. The protocol uses only experimentally friendly photonic resources: coherent and squeezed probes, passive linear optics, and heterodyne/homodyne detection. We then employ an efficient classical post-processing routine that leverages a symplectic regularization step to project matrix estimates onto the symplectic group. In the limit of unbounded input energy, our procedure attains arbitrarily high precision using only $2m+2$ queries, where $m$ is the number of modes. To our knowledge, this is the first provably efficient learning algorithm for a multiparameter family of continuous-variable unitaries.

Authors: Michael A. Bender, Alex Conway, Martín Farach-Colton, Rob Johnson, Prashant Pandey

Filters such as Bloom, quotient, and cuckoo filters are fundamental building blocks providing space-efficient approximate set membership testing. However, many applications need to associate small values with keys-functionality that filters do not provide. This mismatch forces complex workarounds that degrade performance. We argue that maplets-space-efficient data structures for approximate key-value mappings-are the right abstraction. A maplet provides the same space benefits as filters while natively supporting key-value associations with one-sided error guarantees. Through detailed case studies of SplinterDB (LSM-based key-value store), Squeakr (k-mer counter), and Mantis (genomic sequence search), we identify the common patterns and demonstrate how a unified maplet abstraction can lead to simpler designs and better performance. We conclude that applications benefit from defaulting to maplets rather than filters across domains including databases, computational biology, and networking.

Authors: Rohith Reddy Gangam, Shayan Taherijam, Vijay V. Vazirani

We study the classical rent division problem, where $n$ agents must allocate $n$ indivisible rooms and split a fixed total rent $R$. The goal is to compute an envy-free (EF) allocation, where no agent prefers another agent's room and rent to their own. This problem has been extensively studied under standard assumptions, where efficient algorithms for computing EF allocations are known. We extend this framework by introducing two practically motivated constraints: (i) lower and upper bounds on room rents, and (ii) room-specific budget for agents. We develop efficient combinatorial algorithms that either compute a feasible EF allocation or certify infeasibility. We further design algorithms to optimize over EF allocations using natural fairness objectives such as maximin utility, leximin utility, and minimum utility spread. Our approach unifies both constraint types within a single algorithmic framework, advancing the applicability of fair division methods in real-world platforms such as Spliddit.

Authors: Zachary Friggstad, Tobias Mömke

In Capacitated Vehicle Routing with Multiple Depots (CVRP-MD) we are given a set of client locations $C$ and a set of depots $R$ located in a metric space with costs $c(i,j)$ between $u,v \in C \cup R$. Additionally, we are given a capacity bound $k$. The goal is to find a collection of tours of minimum total cost such that each tour starts and ends at some depot $r \in R$ and includes at most $k$ clients and such that each client lies on at least one tour. Our main result is a $3.9365$-approximation based on rounding a new LP relaxation for CVRP-MD.

We present a new primitive for quantum algorithms that implements a discrete Hermite transform efficiently, in time that depends logarithmically in both the dimension and the inverse of the allowable error. This transform, which maps basis states to states whose amplitudes are proportional to the Hermite functions, can be interpreted as the Gaussian analogue of the Fourier transform. Our algorithm is based on a method to exponentially fast forward the evolution of the quantum harmonic oscillator, which significantly improves over prior art. We apply this Hermite transform to give examples of provable quantum query advantage in property testing and learning. In particular, we show how to efficiently test the property of being close to a low-degree in the Hermite basis when inputs are sampled from the Gaussian distribution, and how to solve a Gaussian analogue of the Goldreich-Levin learning task efficiently. We also comment on other potential uses of this transform to simulating time dynamics of quantum systems in the continuum.

Today, of course, is the second anniversary of the genocidal Oct. 7 invasion of Israel—the deadliest day for Jews since the Holocaust, and the event that launched the current wars that have been reshaping the Middle East for better and/or worse. Regardless of whether their primary concern is for Israelis, Palestinians, or both, I’d hope all readers of this blog could at least join me in wishing this barbaric invasion had never happened, and in condemning the celebrations of it taking place around the world.

---

Now for the happy part: today is also the day when the Nobel Prize in Physics is announced. I was delighted to wake up to the news that this year, the prize goes to John Clarke of Berkeley, John Martinis of UC Santa Barbara, and Michel Devoret of Yale, for their experiments in the 1980s that demonstrated the reality of macroscopic quantum tunneling in superconducting circuits. Among other things, this work laid the foundation for the current effort by Google, IBM, and many others to build quantum computers with superconducting qubits. To clarify, though, today’s prize is not for quantum computing per se, but for the earlier work.

While I don’t know John Clarke, and know Michel Devoret only a little, I’ve been proud to count John Martinis as a good friend for the past decade—indeed, his name has often appeared on this blog. When Google hired John in 2014 to build the first programmable quantum computer capable of demonstrating quantum supremacy, it was clear that we’d need to talk about the theory, so we did. Through many email exchanges, calls, and visits to Google’s Santa Barbara Lab, I came to admire John for his iconoclasm, his bluntness, and his determination to make sampling-based quantum supremacy happen. After Google’s success in 2019, I sometimes wondered whether John might eventually be part of a Nobel Prize in Physics for his experimental work in quantum computing. That may have become less likely today, now that he’s won the Nobel Prize in Physics for his work before quantum computing, but I’m guessing he doesn’t mind! Anyway, huge congratulations to all three of the winners.

By Scott

This is a live blog of Lecture 11 of the 2025 edition of my graduate machine learning class “Patterns, Predictions, and Actions.” A Table of Contents is here.

Entire books have been written on the analysis of stochastic gradient descent, but today I’ll give a condensed 90-minute tutorial on what I find most relevant and justifiable in machine learning. This semester, I’m working hard to only present the justifiable parts. What can we say that is true and testable? For optimization of linear prediction functions and convex losses, you can say a lot, and it’s important not to lose sight of this.

Machine learning theory is confusing because anything that relies on how data is distributed, such as assumptions about functional form or probabilistic relations between data points, cannot be verified. However, in optimization, the model of a linear function and a convex loss is under the data analyst’s control. You don’t have to use linear predictors, but if you do, optimization can make you verifiable guarantees. The value of these guarantees in a larger machine learning pipeline is a separate question.

For an introduction to optimization, I wanted something that paralleled the study of the perceptron. Stochastic gradient descent on convex loss functions for linear predictors in binary classification (yes, a mouthful) looks very much like the perceptron update. To see the relationship, let’s use a little mathematical notation. Let x denote the feature vector, y the label (equal to 1 or -1), w the weights, and p = <x,w> the prediction. Then, a stochastic gradient update takes the form

Here, t is a tunable stepsize parameter, and e(u) is some decreasing function that measures errors. For the perceptron, e(u) is equal to 1 when u is negative, 0 when u is nonnegative. For the support vector machine, e(u) is 1 when u-1 is negative, 0 otherwise. For the squared loss, e(u) = u-1. For logistic regression,

No matter which loss function you choose, stochastic gradient for linear classification problems is some variant of the perceptron.

The added algorithmic generality does buy us some nice properties over the perceptron. For example, if you use the squared loss on separable data, you can predict exactly which set of weights this algorithm is converging to, even if there is an infinite set of minimizers. You can easily bound the rate at which it converges to this solution as well. Perceptron-like algorithms naturally handle the problem of overparameterized models and give a simple demonstration of how overparameterization does not impede out-of-sample generalization.

Stochastic gradient analysis is also easy to extend to nonseparable data, allowing you to understand how the perceptron and its variants converge when the data is not perfectly separable. Moreover, you can estimate this convergence without making any probabilistic assumptions about the data.1 Just like with the perceptron, you can convert a nonstochastic analysis into a generalization bound by making probabilistic assumptions about the data-generating process. This is an example of the power of “online-to-batch conversion,” linking deterministic convergence analyses to stories about what the future might look like.

I can derive all of this in 90 minutes.

I like this set of topics because we observe similar phenomena when applying stochastic gradient methods to nonlinear prediction problems. Stochastic gradient methods applied to nonlinear prediction problems are undeniably successful. Overparameterized nonlinear models trained with a constant stepsize converge to zero loss. The choice of optimizer implicitly biases which nonlinear solution you find.

But, though we have some thoughts about it in the book, I decided this year not to speculate much about nonlinear theories of stochastic gradient descent. No matter how much I try to convince myself, I find nonlinear convergence analysis has the same verifiability issues that pop up when we make statistical assumptions about data. You can construct toy models where you can prove something about the dynamics of nonlinear optimization, but it’s never clear these models actually tell you anything about neural networks. I know many people will disagree with me. To those folks: if you come up with something that replaces ADAM as the default solver in PyTorch, then we can talk.

Because without that, I worry that nonlinear optimization theories are mostly irrelevant for machine learning anyway. Do we see interesting, nonlinear dynamics in Weights & Biases plots in real problems? Not really. The number goes down. But more importantly, we don’t care if you can find a global minimum of the training error. We care if you can find a global minimum of the test error.

The dirty secret of machine learning is the actual optimization problem we solve is minimizing the held-out sample error. We often do this by minimizing the training error, and thus linear optimization can play a role similar to that of approximation theory. It gives us a rough guide to practice. It shows us that minimizing training error is possible, that overparameterization does not prevent generalization, and that how you set up your optimization problem dictates which predictor you’ll find. The combination of the optimizer, the architecture, and the hyperparameters implicitly selects a model. These are good lessons.

But while linear models give us good reason to believe that minimizing training error is one way to get decent holdout error, it’s not the only way. As we’ll discuss on Thursday, we always pick the model that has the lowest test error, regardless of whether we have a theoretical justification for the method. In machine learning, we are allowed to do whatever we want to make the holdout error small. We find models by tuning the knobs at our disposal. We have no good theory for how to get the knobs to the best setting. We just try not to have too many knobs.

Subscribe now

By Ben Recht

Linear decision lists are a computational model for Boolean functions built from a sequence of linear threshold function queries. Each query is evaluated in order: if a query returns true, the list outputs the value of the function, and if the answer is false, the process continues to the next query. The size of a linear decision list is the number of queries in it. Linear decision lists form a natural and nontrivial subclass of depth-2 threshold circuits, the class of circuits that currently marks the frontier of explicit circuit lower bounds. While some techniques exist for proving lower bounds against linear decision lists, they are quite limited, leaving important open problems unresolved. Moreover, for the related model of exact linear decision lists, no strong lower bounds are known. We initiate the study of alternation depth of decision lists. The alternation depth is defined as the number of alternations in the output values of the decision list within the sequence of its queries. We show that linear decision lists, with both bounded and unbounded query weights, form fine hierarchies with respect to alternation depth. We establish a similar hierarchy for rectangle decision lists, the model closely related to the communication complexity with $\mathrm{NP}$ oracles. In all settings, we prove strong separations within these hierarchies and between them. Next, we give a lower bound for an explicit function for exact linear decision lists up to depth $n/\log n$. Such lower bounds were not previously known and do not follow directly from existing methods. We also establish a fine depth hierarchy for exact linear decision lists. To prove these hierarchy separations, we introduce an iterative technique, used in combination with existing techniques such as fooling sets and the analysis of blocky matrices. For the lower bound on bounded-depth exact linear decision lists, we combine the discrepancy method with an iterative analysis of blocky matrices.

Korten and Pitassi (FOCS, 2024) defined a new complexity class $L_2P$ as the polynomial-time Turing closure of the Linear Ordering Principle. They put it between $MA$ (Merlin--Arthur protocols) and $S_2P$ (the second symmetric level of the polynomial hierarchy). In this paper we sandwich $L_2P$ between $P^{prMA}$ and $P^{prSBP}$. (The oracles here are promise problems, and $SBP$ is the only known class between $MA$ and $AM$.) The containment in $P^{prSBP}$ is proved via an iterative process that uses a $prSBP$ oracle to estimate the average order rank of a subset and find the minimum of a linear order. Another containment result of this paper is $P^{prO_2P} \subseteq O_2P$ (where $O_2P$ is the input-oblivious version of $S_2P$). These containment results altogether have several byproducts: We give an affirmative answer to an open question posed by of Chakaravarthy and Roy (Computational Complexity, 2011) whether $P^{prMA} \subseteq S_2P$, thereby settling the relative standing of the existing (non-oblivious) Karp-Lipton-style collapse results of Chakaravarthy and Roy (2011) and Cai (2007), We give an affirmative answer to an open question of Korten and Pitassi whether a Karp-Lipton-style collapse can be proven for $L_2P$, We show that the Karp-Lipton-style collapse to $P^{prOMA}$ is actually better than both known collapses to $P^{prMA}$ due to Chakaravarthy and Roy (Computational Complexity, 2011) and to $O_2P$ also due to Chakaravarthy and Roy (STACS, 2006). Thus we resolve the controversy between previously incomparable Karp-Lipton collapses stemming from these two lines of research.

The Department of Computer Science and Technology at the University of Cambridge invites applications for Assistant or Associate Professorships in Theoretical Computer Science, with a focus on Algorithms and Complexity.

For informal inquiries, contact Tom Gur.

Website: https://www.cst.cam.ac.uk/assistantassociate-professor-algorithms-and-complexity
Email: tom.gur@cl.cam.ac.uk

By shacharlovett

Authors: Bruno Cavalar, Eli Goldin, Matthew Gray, Taiga Hiroka, Tomoyuki Morimae

One of the most fundamental problems in the field of hypothesis testing is the identity testing problem: whether samples from some unknown distribution $\mathcal{G}$ are actually from some explicit distribution $\mathcal{D}$. It is known that when the distribution $\mathcal{D}$ has support $[N]$, the optimal sample complexity for the identity testing problem is roughly $O(\sqrt{N})$. However, many distributions of interest, including those which can be sampled efficiently, have exponential support size, and therefore the optimal identity tester also requires exponential samples. In this paper, we bypass this lower bound by considering restricted settings. The above $O(\sqrt{N})$ sample complexity identity tester is constructed so that it is not fooled by any (even inefficiently-sampled) distributions. However, in most applications, the distributions under consideration are efficiently sampleable, and therefore it is enough to consider only identity testers that are not fooled by efficiently-sampled distributions. In that case, we can focus on efficient verification with efficient identity testers. We investigate relations between efficient verifications of classical/quantum distributions and classical/quantum cryptography, and show the following results: (i) Every quantumly samplable distribution is verifiable with a $\mathbf{P^{PP}}$ algorithm. (ii) If one-way functions exist, then no sufficiently random classically samplable distribution is efficiently verifiable. (iii) If one-way functions do not exist, then every classically samplable distribution is efficiently verifiable. (iv) If QEFID pairs exist, then there exists a quantumly samplable distribution which is not efficiently verifiable. (v) If one-way puzzles do not exist, then it is possible to verify sampling-based quantum advantage with a efficient quantum computer.

Authors: Arjan Cornelissen

In this work, we generalize the recently-introduced graph composition framework to the non-boolean setting. A quantum algorithm in this framework is represented by a hypergraph, where each hyperedge is adjacent to multiple vertices. The input and output to the quantum algorithm is represented by a set of boundary vertices, and the hyperedges act like switches, connecting the input vertex to the output that the algorithm computes. Apart from generalizing the graph composition framework, our new proposed framework unifies the quantum divide and conquer framework, the decision-tree framework, and the unified quantum walk search framework. For the decision trees, we additionally construct a quantum algorithm from an improved weighting scheme in the non-boolean case. For quantum walk search, we show how our techniques naturally allow for amortization of the subroutines' costs. Previous work showed how one can speed up ``detection'' of marked vertices by amortizing the costs of the quantum walk. In this work, we extend these results to the setting of ``finding'' such marked vertices, albeit in some restricted settings. Along the way, we provide a novel analysis of irreducible, reversible Markov processes, by linear-algebraically connecting its effective resistance to the random walk operator. This significantly simplifies the algorithmic implementation of the quantum walk search algorithm, achieves an amortization speed-up for quantum walks over Johnson graphs, avoids the need for quantum fast-forwarding, and removes the log-factors from the query complexity statements.

Authors: Marco Fanizza, Larissa Kroell, Arthur Mehta, Connor Paddock, Denis Rochette, William Slofstra, Yuming Zhao

We show that it is undecidable to determine whether the commuting operator value of a nonlocal game is strictly greater than 1/2. As a corollary, there is a boolean constraint system (BCS) game for which the value of the Navascu\'es-Pironio-Ac\'in (NPA) hierarchy does not attain the commuting operator value at any finite level. Our contribution involves establishing a computable mapping from Turing machines to BCS nonlocal games in which the halting property of the machine is encoded as a decision problem for the commuting operator value of the game. Our techniques are algebraic and distinct from those used to establish MIP*=RE.

Authors: Siddhartha Jain, Vishnu Iyer, Rolando D. Somma, Ning Bao, Stephen P. Jordan

We present a new primitive for quantum algorithms that implements a discrete Hermite transform efficiently, in time that depends logarithmically in both the dimension and the inverse of the allowable error. This transform, which maps basis states to states whose amplitudes are proportional to the Hermite functions, can be interpreted as the Gaussian analogue of the Fourier transform. Our algorithm is based on a method to exponentially fast forward the evolution of the quantum harmonic oscillator, which significantly improves over prior art. We apply this Hermite transform to give examples of provable quantum query advantage in property testing and learning. In particular, we show how to efficiently test the property of being close to a low- degree in the Hermite basis when inputs are sampled from the Gaussian distribution, and how to solve a Gaussian analogue of the Goldreich-Levin learning task efficiently. We also comment on other potential uses of this transform to simulating time dynamics of quantum systems in the continuum.

Authors: Idan Attias, Lev Reyzin, Nathan Srebro, Gal Vardi

Despite the theoretical significance and wide practical use of regular expressions, the computational complexity of learning them has been largely unexplored. We study the computational hardness of improperly learning regular expressions in the PAC model and with membership queries. We show that PAC learning is hard even under the uniform distribution on the hypercube, and also prove hardness of distribution-free learning with membership queries. Furthermore, if regular expressions are extended with complement or intersection, we establish hardness of learning with membership queries even under the uniform distribution. We emphasize that these results do not follow from existing hardness results for learning DFAs or NFAs, since the descriptive complexity of regular languages can differ exponentially between DFAs, NFAs, and regular expressions.

Authors: Vasilis Skarlatos, Nikos Konofaos

Conditional Value-at-Risk (CVaR) is a leading tail-risk measure in finance, central to both regulatory and portfolio optimization frameworks. Classical estimation of CVaR and its gradients relies on Monte Carlo simulation, incurring $O(1/\epsilon^2)$ sample complexity to achieve $\epsilon$-accuracy. In this work, we design and analyze a quantum subgradient oracle for CVaR minimization based on amplitude estimation. Via a tripartite proposition, we show that CVaR subgradients can be estimated with $O(1/\epsilon)$ quantum queries, even when the Value-at-Risk (VaR) threshold itself must be estimated. We further quantify the propagation of estimation error from the VaR stage to CVaR gradients and derive convergence rates of stochastic projected subgradient descent using this oracle. Our analysis establishes a near-quadratic improvement in query complexity over classical Monte Carlo. Numerical experiments with simulated quantum circuits confirm the theoretical rates and illustrate robustness to threshold estimation noise. This constitutes the first rigorous complexity analysis of quantum subgradient methods for tail-risk minimization.

Authors: Maximilian R. P. von Liechtenstein

Curved Boolean Logic (CBL) generalizes propositional logic by allowing local truth assignments that do not extend to a single global valuation, analogous to curvature in geometry. We give equivalent sheaf and exclusivity-graph semantics and a context-aware proof calculus that is conservative in the flat limit. We formalize CBL-SAT and basic complexity (NP-complete in general) and present operational operators (CBL-AC and CBL-CONS) that prune contradictions earlier on classical hardware. We model noise with iid, AR(1)-correlated, and adversarial bounded perturbations and provide permutation-based significance with Benjamini-Hochberg FDR control. A Colab-ready notebook (ancillary files) regenerates all figures and statistics. We position CBL relative to KCBS, CSW, and sheaf frameworks and outline links to SAT/CSP and robustness/adapter stability in large language models.

Authors: Tomoyuki Morimae, Yuki Shirakawa, Takashi Yamakawa

One-way puzzles (OWPuzzs) introduced by Khurana and Tomer [STOC 2024] are a natural quantum analogue of one-way functions (OWFs), and one of the most fundamental primitives in ''Microcrypt'' where OWFs do not exist but quantum cryptography is possible. OWPuzzs are implied by almost all quantum cryptographic primitives, and imply several important applications such as non-interactive commitments and multi-party computations. A significant goal in the field of quantum cryptography is to base OWPuzzs on plausible assumptions that will not imply OWFs. In this paper, we base OWPuzzs on hardness of non-collapsing measurements. To that end, we introduce a new complexity class, $\mathbf{SampPDQP}$, which is a sampling version of the decision class $\mathbf{PDQP}$ introduced in [Aaronson, Bouland, Fitzsimons, and Lee, ITCS 2016]. We show that if $\mathbf{SampPDQP}$ is hard on average for quantum polynomial time, then OWPuzzs exist. $\mathbf{SampPDQP}$ is the class of sampling problems that can be solved by a classical polynomial-time algorithm that can make a single query to a non-collapsing measurement oracle, which is a ''magical'' oracle that can sample measurement results on quantum states without collapsing the states. Such non-collapsing measurements are highly unphysical operations that should be hard to realize in quantum polynomial-time. We also study upperbounds of the hardness of $\mathbf{SampPDQP}$. We introduce a new primitive, distributional collision-resistant puzzles (dCRPuzzs), which are a natural quantum analogue of distributional collision-resistant hashing [Dubrov and Ishai, STOC 2006]. We show that dCRPuzzs imply average-case hardness of $\mathbf{SampPDQP}$ (and therefore OWPuzzs as well). We also show that two-message honest-statistically-hiding commitments with classical communication and one-shot signatures [Amos, Georgiou, Kiayias, Zhandry, STOC 2020] imply dCRPuzzs.

Authors: Tesshu Hanaka, Hironori Kiya, Hirotaka Ono

A homeomorphically irreducible spanning tree (HIST) is a spanning tree with no degree-2 vertices, serving as a structurally minimal backbone of a graph. While the existence of HISTs has been widely studied from a structural perspective, the algorithmic complexity of finding them remains less understood. In this paper, we provide a comprehensive investigation of the HIST problem from both structural and algorithmic viewpoints. We present a simple characterization that precisely describes which chordal graphs of diameter at most~3 admit a HIST, leading to a polynomial-time decision procedure for this class. In contrast, we show that the problem is NP-complete for strongly chordal graphs of diameter~4. From the perspective of parameterized complexity, we establish that the HIST problem is W[1]-hard when parameterized by clique-width, indicating that the problem is unlikely to be efficiently solvable in general dense graphs. On the other hand, we present fixed-parameter tractable (FPT) algorithms when parameterized by treewidth, modular-width, or cluster vertex deletion number. Specifically, we develop an $O^*(4^{k})$-time algorithm parameterized by modular-width~$k$, and an FPT algorithm parameterized by the cluster vertex deletion number based on kernelization techniques that bound clique sizes while preserving the existence of a HIST. These results together provide a clearer understanding of the structural and computational boundaries of the HIST problem.

Authors: Adam Bene Watts, Charles R. Chen, J. William Helton, Joseph Slote

Parallelization is a major challenge in quantum algorithms due to physical constraints like no-cloning. This is vividly illustrated by the conjecture of Moore and Nilsson from their seminal work on quantum circuit complexity [MN01, announced 1998]: unitaries of a deceptively simple form--controlled-unitary "staircases"--require circuits of minimum depth $\Omega(n)$. If true, this lower bound would represent a major break from classical parallelism and prove a quantum-native analogue of the famous NC $\neq$ P conjecture. In this work we settle the Moore-Nilsson conjecture in the negative by compressing all circuits in the class to depth $O(\log n)$, which is the best possible. The parallelizations are exact, ancilla-free, and can be computed in poly($n$) time. We also consider circuits restricted to 2D connectivity, for which we derive compressions of optimal depth $O(\sqrt{n})$. More generally, we make progress on the project of quantum parallelization by introducing a quantum blockwise precomputation technique somewhat analogous to the method of Arlazarov, Dini\v{c}, Kronrod, and Farad\v{z}ev [Arl+70] in classical dynamic programming, often called the "Four-Russians method." We apply this technique to more-general "cascade" circuits as well, obtaining for example polynomial depth reductions for staircases of controlled $\log(n)$-qubit unitaries.

Authors: Alexander Kolpakov, Aidan Rocke

We study integer-valued multiplicative dynamics driven by i.i.d. prime multipliers and connect their macroscopic statistics to universal codelengths. We introduce the Multiplicative Turing Ensemble (MTE) and show how it arises naturally - though not uniquely - from ensembles of probabilistic Turing machines. Our modeling principle is variational: taking Elias' Omega codelength as an energy and imposing maximum entropy constraints yields a canonical Gibbs prior on integers and, by restriction, on primes. Under mild tail assumptions, this prior induces exponential tails for log-multipliers (up to slowly varying corrections), which in turn generate Pareto tails for additive gaps. We also prove time-average laws for the Omega codelength along MTE trajectories. Empirically, on Debian and PyPI package size datasets, a scaled Omega prior achieves the lowest KL divergence against codelength histograms. Taken together, the theory-data comparison suggests a qualitative split: machine-adapted regimes (Gibbs-aligned, finite first moment) exhibit clean averaging behavior, whereas human-generated complexity appears to sit beyond this regime, with tails heavy enough to produce an unbounded first moment, and therefore no averaging of the same kind.

Authors: Minki Hhan, Tomoyuki Morimae, Yasuaki Okinaka, Takashi Yamakawa

With the rapid advances in quantum computer architectures and the emerging prospect of large-scale quantum memory, it is becoming essential to classically verify that remote devices genuinely allocate the promised quantum memory with specified number of qubits and coherence time. In this paper, we introduce a new concept, proofs of quantum memory (PoQM). A PoQM is an interactive protocol between a classical probabilistic polynomial-time (PPT) verifier and a quantum polynomial-time (QPT) prover over a classical channel where the verifier can verify that the prover has possessed a quantum memory with a certain number of qubits during a specified period of time. PoQM generalize the notion of proofs of quantumness (PoQ) [Brakerski, Christiano, Mahadev, Vazirani, and Vidick, JACM 2021]. Our main contributions are a formal definition of PoQM and its constructions based on hardness of LWE. Specifically, we give two constructions of PoQM. The first is of a four-round and has negligible soundness error under subexponential-hardness of LWE. The second is of a polynomial-round and has inverse-polynomial soundness error under polynomial-hardness of LWE. As a lowerbound of PoQM, we also show that PoQM imply one-way puzzles. Moreover, a certain restricted version of PoQM implies quantum computation classical communication (QCCC) key exchange.

Authors: Hanwen Shen, Alexander Ushakov

Let $G=F\ast_\varphi t$ be an HNN extension of a free group $F$ with two equal associated normal subgroups $H_1 = H_2$ of finite index. We prove that the word problem in $G$ is decidable in polynomial time. This result extends to the case where the subgroups $H_1=H_2$ are not normal, provided that the isomorphism $\varphi:H_1\to H_2$ satisfies an additional condition described in Section 5.

Authors: Guy Blanc, Caleb Koch, Jane Lange, Carmen Strassle, Li-Yang Tan

We give new evidence that quantum circuits are substantially more powerful than classical circuits. We show, relative to a random oracle, that polynomial-size quantum circuits can sample distributions that subexponential-size classical circuits cannot approximate even to TV distance $1-o(1)$. Prior work of Aaronson and Arkhipov (2011) showed such a separation for the case of exact sampling (i.e. TV distance $0$), but separations for approximate sampling were only known for uniform algorithms. A key ingredient in our proof is a new hardness amplification lemma for the classical query complexity of the Yamakawa-Zhandry (2022) search problem. We show that the probability that any family of query algorithms collectively finds $k$ distinct solutions decays exponentially in $k$.

Authors: Erin Chambers, Tim Ophelders, Anna Schenfisch, Julia Sollberger

A fixed set of vertices in the plane may have multiple planar straight-line triangulations in which the degree of each vertex is the same. As such, the degree information does not completely determine the triangulation. We show that even if we know, for each vertex, the number of neighbors in each of the four cardinal directions, the triangulation is not completely determined. In fact, we show that counting such triangulations is #P-hard via a reduction from #3-regular bipartite planar vertex cover.

Authors: Cheng Xin, Fan Xu, Xin Ding, Jie Gao, Jiaxin Ding

Graph Neural Networks (GNNs) have shown remarkable success across various scientific fields, yet their adoption in critical decision-making is often hindered by a lack of interpretability. Recently, intrinsically interpretable GNNs have been studied to provide insights into model predictions by identifying rationale substructures in graphs. However, existing methods face challenges when the underlying rationale subgraphs are complex and varied. In this work, we propose TopInG: Topologically Interpretable Graph Learning, a novel topological framework that leverages persistent homology to identify persistent rationale subgraphs. TopInG employs a rationale filtration learning approach to model an autoregressive generation process of rationale subgraphs, and introduces a self-adjusted topological constraint, termed topological discrepancy, to enforce a persistent topological distinction between rationale subgraphs and irrelevant counterparts. We provide theoretical guarantees that our loss function is uniquely optimized by the ground truth under specific conditions. Extensive experiments demonstrate TopInG's effectiveness in tackling key challenges, such as handling variform rationale subgraphs, balancing predictive performance with interpretability, and mitigating spurious correlations. Results show that our approach improves upon state-of-the-art methods on both predictive accuracy and interpretation quality.

Authors: Abigail Hickok, Andrew J. Blumberg

We study the relationship between discrete analogues of Ricci and scalar curvature that are defined for point clouds and graphs. In the discrete setting, Ricci curvature is replaced by Ollivier-Ricci curvature. Scalar curvature can be computed as the trace of Ricci curvature for a Riemannian manifold; this motivates a new definition of a scalar version of Ollivier-Ricci curvature. We show that our definition converges to scalar curvature for nearest neighbor graphs obtained by sampling from a manifold. We also prove some new results about the convergence of Ollivier-Ricci curvature to Ricci curvature.

Authors: Jorge Leonardo Ruiz Williams

We introduce a scalable witness-based persistent homology pipeline for full-brain MRI volumes that couples density-aware landmark selection with a GPU-ready witness filtration. Candidates are scored by a hybrid metric that balances geometric coverage against inverse kernel density, yielding landmark sets that shrink mean pairwise distances by 30-60% over random or density-only baselines while preserving topological features. Benchmarks on BrainWeb, IXI, and synthetic manifolds execute in under ten seconds on a single NVIDIA RTX 4090 GPU, avoiding the combinatorial blow-up of Cech, Vietoris-Rips, and alpha filtrations. The package is distributed on PyPI as whale-tda (installable via pip); source and issues are hosted at https://github.com/jorgeLRW/whale. The release also exposes a fast preset (mri_deep_dive_fast) for exploratory sweeps, and ships with reproducibility-focused scripts and artifacts for drop-in use in medical imaging workflows.

Authors: Shankar Prasad Sastry

I present a regression algorithm that provides a continuous, piecewise-smooth function approximating scattered data. It is based on composing and blending linear functions over Voronoi cells, and it scales to high dimensions. The algorithm infers Voronoi cells from seed vertices and constructs a linear function for the input data in and around each cell. As the algorithm does not explicitly compute the Voronoi diagram, it avoids the curse of dimensionality. An accuracy of around 98.2% on the MNIST dataset with 722,200 degrees of freedom (without data augmentation, convolution, or other geometric operators) demonstrates the applicability and scalability of the algorithm.

Authors: Adrian Dumitrescu, János Pach

Let $X$ be a set of $n$ points in the plane, not all on a line. According to the Gallai-Sylvester theorem, $X$ always spans an \emph{ordinary line}, i.e., one that passes through precisely 2 elements of $X$. Given an integer $c\ge 2,$ a \emph{line} spanned by $X$ is called \emph{$c$-ordinary} if it passes through at most $c$ points of $X$. A \emph{triangle} spanned by 3 noncollinear points of $X$ is called \emph{$c$-ordinary} if all 3 lines determined by its sides are \emph{$c$-ordinary}. Motivated by a question of Erd\H os, Fulek \emph{et al.}~\cite{FMN+17} proved that there exists an absolute constant $c > 2$ such that if $X$ cannot be covered by 2 lines, then it determines at least one $c$-ordinary triangle. Moreover, the number of such triangles grows at least linearly in $n$. They raised the question whether the true growth rate of this function is superlinear. We prove that if $X$ cannot be covered by 2 lines, and no line passes through more than $n-t(n)$ points of $X$, for some function $t(n)\rightarrow\infty,$ then the number of $17$-ordinary triangles spanned by $X$ is at least constant times $n \cdot t(n)$, i.e., superlinear in $n$. We also show that the assumption $t(n)\rightarrow\infty$ is necessary. If we further assume that no line passes through more than $n/2-t(n)$ points of $X$, then the number of $17$-ordinary triangles grows superquadratically in $n$. This statement does not hold if $t(n)$ is bounded. We close this paper with some algorithmic results. In particular, we provide a $O(n^{2.372})$ time algorithm for counting all $c$-ordinary triangles in an $n$-element point set, for any $c

Authors: Sanjeev Khanna, Ashwin Padaki, Krish Singal, Erik Waingarten

We study the space complexity of estimating the diameter of a subset of points in an arbitrary metric space in the dynamic (turnstile) streaming model. The input is given as a stream of updates to a frequency vector $x \in \mathbb{Z}_{\geq 0}^n$, where the support of $x$ defines a multiset of points in a fixed metric space $M = ([n], \mathsf{d})$. The goal is to estimate the diameter of this multiset, defined as $\max\{\mathsf{d}(i,j) : x_i, x_j > 0\}$, to a specified approximation factor while using as little space as possible. In insertion-only streams, a simple $O(\log n)$-space algorithm achieves a 2-approximation. In sharp contrast to this, we show that in the dynamic streaming model, any algorithm achieving a constant-factor approximation to diameter requires polynomial space. Specifically, we prove that a $c$-approximation to the diameter requires $n^{\Omega(1/c)}$ space. Our lower bound relies on two conceptual contributions: (1) a new connection between dynamic streaming algorithms and linear sketches for {\em scale-invariant} functions, a class that includes diameter estimation, and (2) a connection between linear sketches for diameter and the {\em minrank} of graphs, a notion previously studied in index coding. We complement our lower bound with a nearly matching upper bound, which gives a $c$-approximation to the diameter in general metrics using $n^{O(1/c)}$ space.

Authors: Hossein Gholizadeh, Yonggang Jiang

In this paper, we discuss the maximum flow problem in the two-party communication model, where two parties, each holding a subset of edges on a common vertex set, aim to compute the maximum flow of the union graph with minimal communication. We show that this can be solved with $\tilde{O}(n^{1.5})$ bits of communication, improving upon the trivial $\tilde{O}(n^2)$ bound. To achieve this, we derive two additional, more general results: 1. We present a randomized algorithm for linear programs with two-sided constraints that requires $\tilde{O}(n^{1.5}k)$ bits of communication when each constraint has at most $k$ non-zeros. This result improves upon the prior work by [Ghadiri, Lee, Padmanabhan, Swartworth, Woodruff, Ye, STOC'24], which achieves a complexity of $\tilde{O}(n^2)$ bits for LPs with one-sided constraints. Upon more precise analysis, their algorithm can reach a bit complexity of $\tilde{O}(n^{1.5} + nk)$ for one-sided constraint LPs. Nevertheless, for sparse matrices, our approach matches this complexity while extending the scope to two-sided constraints. 2. Leveraging this result, we demonstrate that the minimum cost flow problem, as a special case of solving linear programs with two-sided constraints and as a general case of maximum flow problem, can also be solved with a communication complexity of $\tilde{O}(n^{1.5})$ bits. These results are achieved by adapting an interior-point method (IPM)-based algorithm for solving LPs with two-sided constraints in the sequential setting by [van den Brand, Lee, Liu, Saranurak, Sidford, Song, Wang, STOC'21] to the two-party communication model. This adaptation utilizes techniques developed by [Ghadiri, Lee, Padmanabhan, Swartworth, Woodruff, Ye, STOC'24] for distributed convex optimization.

Authors: Yusuf Amidu, Khaled Elbassioni, Adriana F. Gabor

In this paper we propose primal-dual algorithms for different variants of the online resource allocation problem with departures. In the basic variant, requests (items) arrive over time to a set of resources (knapsacks) and upon arrival, the duration of time a request may occupy a resource, the demand and reward if the request can be granted, become known. %We assume that the duration of stay of a request may depend on the resource. %and that resources may have different capacity sizes. The goal of the algorithm is to decide whether to accept/reject a request upon arrival and to which resource to allocate it such that the reward obtained over time is maximized. Under some mild assumptions, we show that the proposed primal-dual algorithm achieves a competitive ratio of $O\big(\log(\bar\theta^{\max}\cdot\bar d^{\max})\big)$, where $\bar \theta^{\max}$ is the maximum value density fluctuation ratio and $\bar d^{\max}$ is the maximum duration fluctuation ratio. We prove similar results for two other variants, namely, one with an additional load balancing constraint, and the multi-dimensional variant where an admitted request consumes capacity on multiple resources. Our results show that the primal-dual approach offers a simple, unified framework for obtaining competitive ratios comparable to those previously obtained via threshold policies known for these problems. Additionally, we show that this framework allows us to incorporate additional constraints, such as load-balancing constraints, without sacrificing the competitive ratio.

Authors: Fabien de Montgolfier, Renaud Torfs

There are three usual definitions of a maximum bipartite clique (biclique) in a bipartite graph\,: either maximizing the number of vertices, or of edges, or finding a maximum balanced biclique. The first problem can be solved in polynomial time, the last ones are NP-complete. Here we show how these three problems may be efficiently solved for two classes of bipartite graphs: Star123-free twin-free graphs, and bounded bimodularwidth twin-free graphs, a class that may be defined using bimodular decomposition. Our computation requires O(n^2) time and requires a decomposition is provided, which takes respectively O(n + m) and O(mn^3) time.

Authors: Bobby Shi, Kevin Tian, Matthew S. Zhang

We survey different perspectives on the stochastic localization process of [Eld13], a powerful construction that has had many exciting recent applications in high-dimensional probability and algorithm design. Unlike prior surveys on this topic, our focus is on giving a self-contained presentation of all known alternative constructions of Eldan's stochastic localization, with an emphasis on connections between different constructions. Our hope is that by collecting these perspectives, some of which had primarily arisen within a particular community (e.g., probability theory, theoretical computer science, information theory, or machine learning), we can broaden the accessibility of stochastic localization, and ease its future use.