Papers for

algorithm designers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Ml expert improves autonomous machine learning model tuning and design

MLExpert: Towards a Generalist Agentic Model for Autonomous Machine Learning Engineering

Abstract: Large language models (LLMs) are expanding from assisting scientific research and engineering to autonomously developing and improving AI systems, advancing AI for AI (AI4AI) as a pathway toward recursive self-improvement (RSI). Workflow-driven machine learning engineering (MLE) systems provide a practical path toward this pursuit through complex orchestration that manages long-horizon experimentation, while recent MLE systems adopt model-directed interaction, allowing models to autonomously organize experiments and adapt optimization strategies based on execution feedback. However, feedback from each experiment reflects several preceding decisions, and a long MLE run contains many such costly experiments. Training must therefore select useful supervision from long interaction trajectories and learn from intermediate outcomes. We propose a post-training method for autonomous long-horizon MLE optimization and apply it to train MLExpert, a 35B Mixture-of-Experts agentic model. We design the Kaggle-MLE Factory to construct executable tasks and an interaction harness for model-directed experimentation. Hierarchical agentic SFT transfers general tool-use and coding capabilities to MLE through outcome-guided supervision. Windowed Interaction RL (WIRL) treats the multi-turn decisions between successive experiment results as an execution window and assigns it a shared outcome-based reward. Asynchronous collection and policy correction support policy updates before the trajectory ends. On MLE-Bench Lite, MLExpert improves the average medal rate of the base model from 37.9% to 72.7%, achieving performance comparable to larger frontier models such as Kimi-K3 and GLM-5.3. Further experiments show that MLExpert improves performance on NatureBench Lite, agent scaffold optimization, and algorithm optimization, suggesting that the learned optimization capability generalizes to other tasks.

Thu 15 OctArtificial IntelligenceComputation and LanguageMachine Learning
The gist
Training machine learning models often requires many trial-and-error experiments, which are costly and take a long time. The authors introduced MLExpert, a large AI system that can better plan and adjust these experiments over long sequences, learning from partial successes along the way. They created special training methods and a testing environment that helped MLExpert double its success rate on a benchmark of machine learning tasks. This suggests MLExpert can help automate and improve the way AI models are developed and optimized without constant human guidance.
Open → 2610.22344v1

Complexity classification of temporal logic problems simplified and extended

Discrete Temporal CSPs et al

Abstract: We revisit the complexity classification of constraint satisfaction problems (CSPs) for first-order reducts of $(\mathbb{Z},<)$, established by Bodirsky, Martin, and Mottet in 2018. Following their approach, we give a self-contained proof of this classification, correcting several errors in the argument. We further show that, with the exception of cases arising from finite-domain CSPs, all tractable cases are solved by a well-known uniform algorithm, eliminating the need for the collection of ad-hoc algorithms used in the original paper. A central component of the proof allows the analysis to be restricted to first-order reducts of $(\mathbb{Z},<)$ that contain the successor relation. We substantially simplify this reduction and generalize the underlying construction. This generalization allows us to apply the same technique to first-order reducts of the triangular lattice graph and of infinite regular trees, yielding a complete complexity classification for these classes of structures, in particular a $\mathsf{P}$ versus $\mathsf{NP}$-complete dichotomy.

Thu 15 OctComputational Complexity
The gist
This paper looks at a kind of puzzle called constraint satisfaction problems (CSPs) that involve ordering numbers like integers. The authors revisited and fixed earlier work that classified how hard these puzzles are to solve. They showed that most puzzles that can be solved easily all work well with one standard solving method, instead of many different special tricks. Additionally, they simplified the way to study these puzzles and extended the results to similar puzzles on different structures, like infinite trees and lattices, categorizing them as either easy or hard to solve.
Open → 2610.21967v1

Computing best rank 2 nonnegative matrix factorization is strongly NP-hard

Strong NP-Hardness of Rank-2 Nonnegative Matrix Factorization

Abstract: Nonnegative matrix factorization (NMF) approximates a nonnegative matrix by the product of two nonnegative matrices with a prescribed inner dimension~$r$. The existence of an exact NMF can be decided in polynomial time for every fixed~$r$, and a best rank-$1$ NMF in the Frobenius norm can be obtained from a truncated singular value decomposition. We prove that computing a best rank-$2$ NMF in the Frobenius norm is strongly NP-hard. Our proof uses a polynomial-time reduction from \textsc{Clique} that produces symmetric positive-definite, completely positive matrices with polynomially bounded integer entries. The same reduction also establishes strong NP-hardness of rank-$2$ symmetric NMF.

Thu 15 OctComputational Complexity
The gist
Nonnegative matrix factorization (NMF) is a way to break down a large table of numbers into two smaller tables, all containing only positive numbers. This helps find patterns in data like images or text. For very simple cases, it’s easy and fast to find the best factorization, but this paper shows that for the next simplest case, called rank-2, finding the best factorization is actually very hard for computers. The authors prove this by connecting the problem to a well-known tough problem called Clique. This means there’s no quick method likely to work well for every case of rank-2 NMF.
Open → 2610.21874v1

Query complexity for finding fixed points grows in six dimensions

The Six-Dimensional Tarski Problem is $Ω(\log^3 n)$-Hard

Abstract: We study the deterministic query complexity of finding a fixed point of a monotone function $f:[n]^d\to[n]^d$, where querying $x$ returns $f(x)$. For fixed $d\ge2$, earlier work established a lower bound of $Ω((\log n)^2)$ and an upper bound of $O_d((\log n)^{\lceil(d+2)/3\rceil})$ for the query complexity. Very recently, several papers obtained improved lower bounds using AI-assisted proofs. In this paper, we further improve these lower bounds to $\text{Tarski}(n,d)=Ω_d((\log n)^{2+\lfloor\log_3(d/2)\rfloor})$. In particular, we obtain the optimal $Θ((\log n)^3)$ deterministic query complexity in six dimensions.

Thu 15 OctComputational Complexity
The gist
The paper looks at how hard it is for a computer to find a special point where a given function doesn't change its value, called a fixed point, when the function works in multiple dimensions. The authors improve the understanding of how many questions (queries) a program must ask to find this fixed point, especially when there are six dimensions involved. They showed that in six dimensions, the complexity is roughly proportional to the cube of the logarithm of the size of the input, which means it takes more queries than was previously proven. This helps clarify the difficulty of solving these kinds of problems deterministically.
Open → 2610.21785v1

Constant stepsize sgd iterates closely follow a specific gaussian pattern

Sharp Stationary Gaussian Approximation for Constant-Stepsize SGD

Abstract: We prove a sharp Gaussian approximation for the invariant law of constant-stepsize SGD with bounded additive noise generated by an exogenous uniformly ergodic Markov chain. For a smooth, strongly convex objective with a Lipschitz Hessian and nondegenerate long-run noise covariance, the centered iterate normalized by the square root of the stepsize is $O(\sqrtα)$-close in 1-Wasserstein distance to its limiting Gaussian. The proof combines blockwise Gaussian comparison with long-run contraction. A four-state example gives a matching lower bound although the one-time noise marginal is symmetric and every nonzero-lag autocovariance vanishes. In this example, an adjacent third-order mixed moment produces the leading correction.

Wed 30 SeptMachine Learning
The gist
Stochastic gradient descent (SGD) is a method often used to find the best settings for a model by taking small steps. This paper shows that when these steps have a fixed size and the noise involved behaves well, the long-term behavior of the updates can be closely approximated by a bell-shaped curve (Gaussian). The authors prove a precise mathematical way to measure how close the updates are to this curve and demonstrate why this approximation is sharp. They also provide an example where this approximation is as accurate as possible, giving insight into the noise's role in the process.
Open → 2609.39144v1

Deep neural networks learn smooth functions efficiently in high dimensions

Minimax rates for learning spectral Barron functions by deep ReLU neural networks

Abstract: We study how well deep neural networks approximate and learn spectral Barron functions. Recent studies have shown that these function classes can be efficiently approximated by shallow neural networks without suffering from the curse of dimensionality. We complement these results by providing new approximation bounds for deep networks with ReLU activation and establishing the minimax rates for learning these function classes. Specifically, we show that $d$-dimensional spectral Barron functions with smoothness index $s>0$ can be approximated by deep ReLU neural networks with approximation rate $\widetilde{\mathcal{O}} (S^{-\frac{1}{2}-\frac{s}{d}})$, where $S$ denotes the number of nonzero parameters in the network. Using this approximation result, we further show that deep ReLU neural networks can learn spectral Barron functions in a fast rate $n^{-\frac{d+2s}{2d+2s}}$ with $n$ training samples. Finally, we prove that this convergence rate is minimax optimal up to logarithmic factors.

Wed 30 SeptMachine Learning
The gist
Some kinds of smooth mathematical functions, called spectral Barron functions, can be learned and approximated by neural networks without becoming too complicated as the number of dimensions grows. The authors show that deep networks with ReLU activations can approximate these functions well, with a specific rate related to the network size and function smoothness. They also prove that learning these functions from data with a deep network can be done nearly as quickly as is theoretically possible. Their results provide a mathematical guarantee on how well deep learning can capture this class of functions.
Open → 2609.39020v1

Statistical bounds for asynchronous td learning with markov data

Sharp Statistical Rates for Asynchronous TD Learning with Markovian Data

Abstract: We study the last iterate of standard tabular temporal-difference (TD) learning from a single trajectory of a finite Markov reward process. For discount factor $γ$, write $H=(1-γ)^{-1}$, and let $μ_{\min}$ and $t_{\operatorname{mix}}$ denote the minimum stationary probability and total-variation mixing time. We prove that last-iterate TD achieves sup-norm error at most $\varepsilon$ with high probability using$\widetilde O\left( \frac{H^3}{μ_{\min}\varepsilon^2} +\frac{t_{\operatorname{mix}}}{μ_{\min}} \right)$ transitions, for $0<\varepsilon\leq1$. This rate holds both for a constant step size selected for the target accuracy and for a decreasing schedule independent of the target accuracy and terminal time. The latter gives a simultaneous guarantee over all times beyond an explicit transient threshold. The statistical term retains the cubic effective-horizon dependence of synchronous TD, and the additive mixing transient has no extra horizon factor. The result allows non-reversible chains, arbitrary initial state distributions, and bounded rewards that may depend on the next state. The proof uses an anchored local Poisson equation in reverse time to control stochastic fluctuations without a mixing-time factor, and a hitting-time compensation identity to bound initialization error. The latter also yields a finer transient in terms of the worst expected reverse hitting time. A bound on the expected cumulative propagation mass extends this argument to decreasing step sizes. A three-state construction with known deterministic rewards gives matching minimax lower bounds for the statistical and mixing terms, up to logarithms, over specified model classes in a slow-mixing parameter regime.

Wed 30 SeptMachine Learning
The gist
Temporal-difference (TD) learning is a way machines predict future rewards based on past experience, but this prediction can be noisy and slow to learn. The paper studies how quickly and accurately TD learning finished running can get close to the best prediction using data generated by a Markov process, which models things that change based on current state. They find precise rates on how long learning takes depending on factors like how much future rewards are valued and how quickly states mix. Their results hold under various conditions and match the best possible bounds, meaning they show TD learning is as efficient as theoretically expected in these settings.
Open → 2609.38880v1

Linear oracle calls cannot beat existing regret rates in online learning

Lower Bounds for Linear-Oracle Online Learning

Abstract: Can a constant number of linear minimizations per round improve on the $T^{3/4}$ regret rate of online Frank-Wolfe on general convex sets? Weibel et al. conjectured that fixed-coefficient methods cannot. We prove their conjecture and extend the lower bound to every deterministic learner in an oracle-only model. The learner receives an initial feasible point and a diameter bound, and must remain feasible on every domain consistent with its oracle replies. For $T$ rounds, at most $b$ calls between decisions, diameter bound $D$, and gradient norm bound $L$, we construct an instance in dimension $d=2b(T-1)+1$ with regret at least $2^{-1/4}LDb^{-1/4}T^{3/4}$. The adversary fixes the domain, initial point, deterministic tie rule and linear losses before play. The vertices form a path on which every point available before a decision has zero current loss, while the final vertex has negative loss on every round. For constant $b$, the result matches the known upper rate for dimension-independent guarantees. For one-call fixed schedules with a nonzero coefficient on the newest gradient, a second construction gives regret at least $3LDT^{3/4}/4$ with unique minimizers at every issued query. Exact-arithmetic certificates for the tuned schedule of Weibel et al. closely match their finite-horizon numerical worst cases, with unique oracle replies.

Tue 29 SeptMachine Learning
The gist
This paper studies how well certain online learning methods can do when they are allowed only a limited number of simple queries (linear minimizations) each step. These methods try to minimize their mistakes over time but often hit a certain speed limit. The authors prove that no method following fixed rules with only a few of these linear queries per step can get better than a known slower rate of learning, measured by something called "regret." They build specific examples that show this limit is real and tight, confirming previous guesses about these algorithms.
Open → 2609.38375v1

Algorithm solves three-color Free-Flood-It on fixed-height grids efficiently

Three-Color Free-Flood-It on Fixed-Height Grids Is Polynomial-Time Solvable

Abstract: We give a deterministic algorithm for \textsc{Free-Flood-It} on rectangular grids $P_k\square P_n$ with at most three colors. For every fixed height $k$, it computes the minimum number of moves and an optimal sequence in $N^{O(k^2)}$ time, where $N=kn$. This resolves the previously open three-color case on complete $3\times n$ boards. The proof uses a representation of flooding strategies as paintings by connected regions. We show that an optimal painting can be chosen so that its regions form a rooted tree with strong restrictions on the colors along ancestral paths. These restrictions make the part of the tree visible in any fixed-size connected window admit only polynomially many descriptions. The remaining common ancestors may form an arbitrarily long chain. We retain that chain on a stack and use a finite context-free recurrence to minimize the total painting cost without enumerating all possible stack contents. Connectivity information at the boundary ensures that the resulting local descriptions assemble into one valid global painting. The argument also applies to graphs supplied with an ordering into connected layers of bounded size, provided every edge lies within one layer or joins consecutive layers. A family of three-row boards shows that the unbounded ancestor chains handled by the algorithm are necessary even for optimal paintings. For any fixed height and palette size, we also give a deterministic EPTAS and a randomized sampling variant with an explicit failure-probability bound. These approximation results use a separate algorithm with single-exponential dependence on the move budget.

Tue 29 SeptComputational ComplexityData Structures and Algorithms
The gist
Free-Flood-It is a puzzle game where you change the colors of connected squares to make the whole board one color with as few moves as possible. The paper presents an algorithm that finds the best way to solve this game on rectangular grids with three colors and a fixed height. The authors show that their method runs in time that grows reasonably with the board size, making the problem easier to solve than previously known. They also provide approximation methods for more general cases.
Open → 2609.37118v1

Improved bounds found for sign patterns in matrices with plus minus one entries

Three Standard Deviations Suffice While One Does Not

Abstract: Spencer's 1985 ``six standard deviations suffice'' theorem shows that every $A \in [-1,1]^{n \times n}$ has a sign vector $x \in \{-1,1\}^n$ with $\|Ax\|_\infty \le 6\sqrt{n}$. We show the upper bound $\sqrt{3\operatorname{arsinh}(10)}\sqrt{n}+4 < 2.9992 \sqrt{n} + 4$ by directly rounding the minimizer of a potential function to a vertex of the cube. We also show that, for every power of two $n \ge 2^{50}$, there exists a matrix $A \in \{-1,1\}^{n \times n}$ such that $\|Ax\|_\infty >1.0000002\sqrt{n}$ for every choice of signs $x \in \{-1,1\}^n$. The construction simply replaces a $2^{-22}$ fraction of the columns of a Hadamard matrix with independent random sign vectors. This is the first improvement over the $\sqrt{n}$ lower bound of Olson and Spencer (1978), which uses a Hadamard matrix.

Mon 28 SeptDiscrete Mathematics
The gist
This paper studies how to assign plus or minus signs to columns of a matrix so that the largest resulting value is as small as possible. A previous result said you can keep this maximum value under about six times the square root of the matrix size. The authors improve this to less than three times the square root, showing fewer signs are needed to control the outcome. They also find that one times the square root is not always possible by constructing special large matrices where the maximum has to be slightly bigger than that.
Open → 2609.34471v1

Complexity classification of cubic bipartite holant problems with fixed weights

A Dichotomy for Cubic Bipartite Holant Problems with Complex Algebraic Weights

Abstract: We classify the exact evaluation of $\operatorname{Holant}(f\mid=_3)$ for every fixed complex algebraic symmetric Boolean ternary signature $f$. An input is a cubic bipartite multigraph: every vertex on one side carries $f$, every vertex on the other side carries ternary equality, and no auxiliary signatures are freely available. The tractable signatures are precisely rank-one tensors, generalized equalities, and equality-preserving cube-root diagonal transformations of six affine signatures, together with nonzero scalings and reversal. Every other signature gives a $\#\mathrm{P}$-hard problem under polynomial-time Turing reductions. We also identify the exact real intersection: it consists of the same tractable families as in the rational classification, with real algebraic parameters. The proof preserves degree exactly three on both sides of every oracle instance. A rank-one matrix extracted by interpolation supplies one unary signature only after its unused factor has been absorbed in triples. Over the complex numbers this absorption has three exceptional projective directions. We combine this constraint with projective matrix-group orbits, explicit ternary replacements, and an exhaustive treatment of finite projective orders. The cases of orders three and five include exact polynomial certificates; the certificate identities and a rational-arithmetic verifier are supplied as supplementary material.

Sun 27 SeptComputational Complexity
The gist
This paper studies a special kind of computational problem involving networks with two types of nodes and fixed rules at each node. The authors completely classify which problems can be solved easily and which ones are computationally very hard based on the fixed rules, called signatures. They handle complex number weights and provide exact mathematical conditions separating the easy from the hard cases. Their work reveals deep structural properties and uses advanced mathematical tools to prove the classification.
Open → 2609.33473v1

Complexity of finding equilibrium in network games clarified

The Complexity of Nash Equilibrium in Network Congestion and Coordination Games

Abstract: We show that computing a Nash equilibrium is CLS-complete for linear network congestion and network coordination games. As a result, finding a KKT point of a bilinear polynomial is CLS-complete.

Sun 27 SeptComputer Science and Game TheoryComputational Complexity
The gist
This paper studies how hard it is to find stable outcomes called Nash equilibria in certain network-based games where players share resources or coordinate actions. The authors show that computing these equilibria is as hard as a class of problems known as CLS-complete. This means finding such equilibria is computationally challenging and unlikely to have easy algorithms. They also relate this complexity result to finding special points called KKT points in certain mathematical problems.
Open → 2609.33225v1

AltGDA method guarantees steady convergence in matrix game solutions

AltGDA Achieves Global $O(1/T)$ Ergodic Convergence in Matrix Games

Abstract: Alternating gradient descent-ascent (AltGDA) is a simple and practically effective method for solving finite two-player zero-sum matrix games. However, the theory of AltGDA remains limited: existing results either apply only to unconstrained settings or require restrictive assumptions on the equilibrium in constrained settings. We show that AltGDA converges globally at an $O(1/T)$ ergodic rate in every finite two-player zero-sum matrix game. Unlike prior results, our guarantee holds for every initialization and every horizon $T$: the uniform averages of the AltGDA iterates satisfy an $O(1/T)$ duality-gap bound. Our proof is inspired by numerical results obtained using a novel performance estimation programming (PEP) framework for Lyapunov function search over compact convex sets. Additionally, we provide simple counterexamples showing that the last-iterate duality gap of AltGDA does not converge to zero. This justifies why averaging of iterates is indeed necessary to achieve an $O(1/T)$ rate. We have formalized and machine-checked our global ergodic convergence result in Lean 4.

Sat 26 SeptComputer Science and Game Theory
The gist
Two-player zero-sum games, like rock-paper-scissors, can be solved by finding a balance where neither player benefits from changing their strategy. The authors show that a simple method called alternating gradient descent-ascent (AltGDA) reliably gets closer to this balance at a steady rate, no matter where it starts or the length of play. Their proof uses a new technique to track performance and confirms that averaging moves is necessary for steady progress. They also verified their result with formal computer checking to ensure accuracy.
Open → 2609.32995v1

One-tape turing machines show sharp change in counting complexity

Accepting-Path Counting at the One-Tape $n\log n$ Threshold

Abstract: We observe that the classical $n\log n$ time threshold for one-tape Turing machines is also a threshold for their accepting-path counts. Below it, every nondeterministic one-tape machine running in strong $o(n\log n)$ time has a rational ordinary generating function of accepting-path counts. At strong $O(n\log n)$ time, the situation changes completely: there is a fixed one-tape machine whose accepting-path function is complete for $\#\mathsf P_1$, the tally analogue of $\#\mathsf P$, under parsimonious polynomial-time tally reductions. A second construction within the same time bound gives positive accepting-path counts with a noncomputable exponential growth rate. The rationality result combines the one-tape time gap with the linear-time counting theorem of Tadaki, Yamakami and Lin. The completeness proof adapts the linear-time universal counting machine of Beame et al. to the one-tape setting.

Sat 26 SeptComputational Complexity
The gist
Some computer models called one-tape Turing machines run tasks and count their possible solutions. The authors found that if such a machine runs faster than roughly n times log n steps, the counting pattern of solutions is simple and predictable. But if it runs at n times log n steps or slower, the counting becomes very complex, even matching the difficulty of some well-known hard problems. They also showed examples where the number of solutions grows in a way that can't be calculated by any algorithm.
Open → 2609.32959v1

Framework relates different machine learning methods by complexity and resources

Structuring Relations Among Learning Paradigms via Protocol--Objective--Resource Reductions

Abstract: Modern machine learning spans supervised, transfer, continual, meta-learning, and related regimes that often reuse the same hypothesis classes, architectures, and optimizers but differ in information access, objectives, memory, adaptation, and sample accounting. This makes it difficult to determine whether one paradigm is genuinely distinct, a special case of another, or part of a broader structural hierarchy. We introduce a protocol-objective-resource (POR) framework that separates representational capacity from these design choices. A paradigm is specified by an environment class, observation protocol, admissible learners, performance functional, and resource accounting rule. POR reductions combine environment embeddings, learner compilers, threshold maps, and calibrated resource overheads. Our main theorem shows that such reductions imply worst-case complexity domination on embedded comparison classes, transferring upper bounds forward and lower bounds backward; under labeled-example accounting, this yields sample complexity domination. We also show that calibrated nontrivial accuracy regimes are necessary to avoid vacuous comparisons, and that strengthening the objective can strictly increase minimax sample complexity even with unchanged protocols and learner classes. Instantiating the framework for supervised, transfer, continual, and meta-learning yields canonical special-case relations: continual contains transfer, transfer contains supervised, and meta-learning contains supervised under aligned raw-example accounting. We further derive a non-exact episode-to-example reduction for episodic meta-learning and capture within-paradigm refinements such as replay memory and task identifiers. The framework thus provides a unified language for structuring learning paradigms and transferring complexity guarantees across them.

Sat 26 SeptMachine Learning
The gist
Machine learning has many ways to learn from data, like supervised, transfer, continual, and meta-learning, which can seem different but often share parts. The authors created a framework that breaks down these learning methods by how they get data, what goals they have, and what resources they use. This framework helps show when one learning method includes or relates to another and lets us compare how hard or easy they are to learn from. They proved mathematically that these relationships affect the minimum necessary examples and performance bounds. Their work provides a clear language to understand and connect different machine learning approaches.
Open → 2609.32766v1

Boundaries for advice and information in membership decision problems

Linear Certificates for Membership Comparability, Quadratic Barriers for Selectors

Abstract: Selectors and comparators supply only partial information about membership: a selector names a member of any pair that meets the language, while a binary membership comparator merely excludes one of the four membership vectors of a pair. We ask how much nonuniform advice turns such information into exact recognition. Our main result extends the optimal nondeterministic advice bound for P-selective sets to every binary membership-comparable language: $2-mc \subseteq NP /(3n+5)\cap\mathrm{coNP}/(3n+5)$, with common fixed advice and certificates of at most $5n+12$ bits. The class is strictly larger; some 2-mc sets are not truth-table reducible to any P-selective set. The proof replaces the tournament king by an independent two-step cover of true signed literals, together with a short-forcing-or-exact-majority dichotomy, and it relativizes. Via an advice-preserving isolation transfer, a deterministic polynomial-time algorithm for promise Unique-Circuit-SAT gives $2-mc \subseteq P/O(n)$. For selectors we determine tight orders of ordinary advice: $Θ(n)$ for errorless average-case computation and $Θ(n^2)$ for worst-case bounded-error computation, the latter independent of the interpreter's coin bound. One oracle realizes both orders on a single language and separates ordinary from coin-dependent advice. The quadratic and linear lower bounds hold for tournament-query procedures and relativized languages, not unconditionally for unrelativized P-selective sets.

Fri 25 SeptComputational Complexity
The gist
Deciding if a certain item belongs to a group can be tricky when only limited information is available. The authors study how extra hints, called advice, help turn partial information into exact decisions. They find new limits on the amount and types of advice needed for these decisions in complex cases, extending previous knowledge. Their work also explores how these limits change with different kinds of algorithms and randomness. This helps us understand what information is fundamentally needed to solve certain computational problems.
Open → 2609.31053v1

Proof shows large posets force near equal ordering probabilities

Proof of the Kahn Saks Conjecture

Abstract: Let $\mathbb{P}(x\prec y)$ be the probability that $x$ precedes $y$ in a uniformly random linear extension of an $n$-element poset $P$, and define the balancing coefficient to be $δ(x,y)=\min(\mathbb{P}(x\prec y),\mathbb{P}(y\prec x))$ with $δ(P)=\max_{x,y}δ(x,y)$. We prove (Theorem 1) that sufficiently large width forces $δ(P)$ to be arbitrarily close to $1/2$, answering a long-standing conjecture of Kahn and Saks. In fact, we prove the stronger result (Theorem 2) that large width forces one of two configurations in our poset: either a nearly uniform order on $k$ vertices, or an almost fixed order on $t$ vertices with one further vertex inserted uniformly among the $t+1$ slots. We also show that, for fixed $k$, the first possibility must occur within any antichain $X$ of size $Ω(n^{2/3})$.

Fri 25 SeptDiscrete Mathematics
The gist
This paper settles a long-standing question about how items are arranged in special ordered sets called posets. The authors prove that when these sets are wide enough, certain pairs of items almost equally likely appear before one another in random arrangements. They identify two specific patterns that must exist in such large posets. This improves our understanding of how order behaves in complex structured data.
Open → 2609.30895v1

Approximate degree of composed boolean functions multiplies exactly

A General Composition Theorem for Approximate Degree

Abstract: A longstanding open question in Boolean function complexity asks whether approximate degree composes multiplicatively under block composition. Although a general multiplicative upper bound is known, matching lower bounds have previously been established only for restricted classes of functions. We resolve this question for all total Boolean functions by proving the matching lower bound. Together with Sherstov's upper bound, our result shows that, for every pair of total Boolean functions $f:\{0,1\}^n\to\{0,1\}$ and $g:\{0,1\}^m\to\{0,1\}$, \[ \widetilde{deg}(f\circ g) = Θ\!\left( \widetilde{deg}(f)\,\widetilde{deg}(g) \right), \] where $\widetilde{deg}$ denotes constant-error approximate degree.

Thu 24 SeptComputational Complexity
The gist
A key question in computer science was whether the difficulty of approximating combined Boolean functions multiplies as expected. The authors proved this is true for all total Boolean functions, meaning the approximate degree of a composition equals the product of the individual approximate degrees. This resolves a long-standing question and matches earlier upper bound results. Their work confirms a precise mathematical relationship when combining these functions.
Open → 2609.30139v1

Lovasz-Theta value of random graphs tightly determined at square root of n

Sharp Lovasz-Theta Bounds on Random Graphs

Abstract: It is well known that the \Lovasz-Theta function of a random graph $G(n,\tfrac{1}{2})$ is $Θ(\sqrt{n})$. More precisely, it is tightly concentrated in the interval \( [\sqrt{n},\, 2\sqrt{n}], \) where the upper bound follows from an explicit dual witness for the associated semidefinite program. Numerical evidence and heuristic arguments suggest that the true value is $(1+o(1))\sqrt{n}$. However, closing this gap has remained a longstanding challenge, resisting existing techniques even in light of recent progress on sharp algorithmic thresholds and non-asymptotic free probability. In this work, we resolve this question by proving that the \Lovasz-Theta function of $G(n,\tfrac{1}{2})$ is $(1+o_n(1))\sqrt{n}$ with high probability, determining its asymptotic value up to vanishing relative error.

Thu 24 SeptComputational ComplexityDiscrete Mathematics
The gist
Random graphs, which connect points in a random way, have a number called the Lovasz-Theta function that helps understand their structure. It was known this number grows roughly like the square root of the number of points, but the exact growth was uncertain. The authors have proven that this function essentially equals the square root of the number of points as the graph becomes very large. This solves a question that has been open for a long time using advanced mathematical techniques.
Open → 2609.30064v1

Complexity rises in multiplayer Blotto games with player-specific values

The Complexity of Multiplayer Colonel Blotto Games with Player-Specific Values

Abstract: We study equilibrium computation in discrete multiplayer Colonel Blotto games with player-specific battlefield values. In the two-player model with common battlefield values, equilibria can be computed in polynomial time. We show that this tractability breaks down in the multiplayer model with player-specific values under the standard uniform tie-breaking rule. In particular, computing a $(c/n)$-approximate Nash equilibrium is PPAD-hard for some constant $c>0$, even when every player has three resources, where $n$ is the number of players. The main technical step is PPAD-hardness for computing a constant-approximate well-supported Nash equilibrium. In contrast, under uniform tie-breaking, a pure Nash equilibrium can be computed in polynomial time when every player has one resource. We also prove PPAD membership for computing $\varepsilon$-approximate Nash equilibria for inverse-exponentially small $\varepsilon$. Finally, for non-uniform monotone tie-breaking, we show PPAD-hardness even when every player has one resource and all players have identical battlefield values.

Thu 24 SeptComputer Science and Game TheoryComputational Complexity
The gist
This paper looks at how hard it is to find stable strategies in a complex game where players allocate limited resources across battlefields. When only two players compete with the same values, finding these strategies is easier and fast. But when there are many players and each values battlefields differently, figuring out stable strategies becomes much harder. The authors prove that even small approximations of solutions are very difficult to compute in these multiplayer, personalized settings. However, for some simple cases with very limited resources, stable solutions can still be found efficiently.
Open → 2609.30019v1

Pairs of knapsack value and size patterns that can actually happen

Inverse knapsack at two capacities: which pairs of value-cardinality hulls are realizable?

Abstract: One item set evaluated at two capacities $R<D$ produces two concave hulls of optimal value against cardinality. We ask which prescribed pairs arise. Exchange arguments give a necessary system on vertex witnesses, exchange closure (EC), whose scalar consequences form the linear closure. We exhibit a pair satisfying every scalar test that fails EC, so the linear closure is strictly larger already at larger terminal count three; and a globally coherent EC witness admitting no common-size representation although its target pair is realizable. Under a cardinality cap, a four-band classification of one family gives exact thresholds for cap-four realizability, uncapped realizability and the vertex-only capped closure. Pairs whose larger terminal count is at most two are characterized. Under the explicit encoding the decision problem lies in $Σ_2^p$ and is polynomial-time for fixed terminal cardinalities. Exact finite certificates establish agreement of the scalar and witness conditions on six specified domains; sufficiency of uncapped EC remains open.

Wed 23 SeptDiscrete MathematicsData Structures and Algorithms
The gist
This paper studies a problem related to the knapsack, a way to pick items with values that fit into limited spaces. When you measure best values you can get for two different size limits, you get two patterns. The authors investigate which pairs of such patterns are possible. They find a mathematical system that checks some necessary conditions, but also show this is not always enough. They classify some cases fully and analyze the complexity of deciding if a pair is possible.
Open → 2609.28128v1

Substantive agency characterization links key complexity classes conditionally

Substantive Agency and Computational Non-Anticipability: An Axiomatic Route to a Conditional Separation of P and N P

Abstract: This paper characterises substantive agency and identifies the additional bridges under which it has a standard complexity-theoretic consequence: conditionally, P __ = N P . The constitutive core separates coherent plurality, causal openness, anticipatory non-pointing, act-level singularisation, and endogenous sourcehood. Its temporal claim yields a two-sided modal result: exact passive pre-act selection is incompatible with jointly retaining singularising priority and invariance under causally inert informational extension. If every standard polynomial procedure is deployable in that passive form, the actualisation map $α$ has no polynomial-time selector. On an effective presentation, $α$ is therefore either computable outside FP or noncomputable. A separate certifiedactualisation protocol supplies polynomially bounded, polynomially verifiable traces with extensional unique projection. This is the constructive interface that turns historical actualisation into a total standard search relation; combined with the modal result, it places that relation in TFNP search \ FP search , from which a self-contained search argument yields P __ = N P . The result is a domain-relative conditional transfer theorem: it neither assumes polynomial non-anticipability in the definition of agency nor proves that human decision-making satisfies the bridge and certification premises.

Wed 23 SeptLogic in Computer Science
The gist
This paper explores a formal way to describe decision-making called substantive agency and connects it to a major question in computer science about whether all problems whose solutions can be checked quickly can also be solved quickly (the P vs NP problem). The authors show that under specific conditions involving how decisions can be chosen or predicted, this leads to an important conclusion about P and NP being equal. However, their result depends on assumptions and does not prove that human decisions meet these criteria. Instead, it provides a conditional theoretical bridge between concepts in agency and computational complexity.
Open → 2609.28040v1

Parameter complexity analysis of temporal domination problems in modular graphs

The parameterised complexity of generalised temporal domination on temporal graphs with modular structure

Abstract: Inspired by the static problem $(α,β)$-Dominating Set, we propose a general temporal domination problem, called $(α,β)$-Temporal Dominating Set ($(α,β)$-TDS). We show that this problem encompasses Temporal Dominating Set, and additionally provides first temporal extensions of problems such as $k$-Dominating Set and $α$-Dominating Set. In this paper, we study the parameterised complexity of $(α,β)$-TDS with respect to temporal neighbourhood diversity (TND), temporal modular-width (TMW), and temporal cliquewidth (TCW). We obtain fixed parameter tractability results for all values of $α$ and $β$ with respect to TND; W[1]-hardness with respect to TMW and TCW whenever $β$ is in the problem input, or whenever $α\in (0,1)$ and $β$ is a fixed constant; and para-NP-hardness with respect to TCW when $α= 0$ and $β= 1$, or $α= 1$ and $β= 0$.

Tue 22 SeptDiscrete Mathematics
The gist
This work looks at a problem where you want to pick nodes in a changing network so that they can influence or cover their neighbors over time in specific ways. The authors study how hard it is to solve this problem depending on how the network is structured and which parameters you choose. They find situations where the problem can be solved efficiently and others where it becomes very difficult. This helps us understand when certain network analysis tasks are feasible as things change over time.
Open → 2609.26366v1

Permutation group problems shown to have high computational complexity

Word Length and Diameter in Permutation Groups

Abstract: The input for the binary diameter problem consists of explicitly represented permutations generating a finite group $G$ and a binary-encoded nonnegative integer $k$. The question is whether every element of $G$ is a product of at most $k$ input generators. For the binary length problem, the input contains in addition a permutation $g \in G$ and it is asked whether $g$ is a product of at most $k$ input generators. We prove that the binary diameter problem is PSPACE-complete. When restricted to $2$-step nilpotent groups, the binary diameter problem is shown to be complete for $\mathsf{Π_2^P}$, whereas the binary length problem is shown to be NP-complete. Without the restriction to $2$-step nilpotent groups, the binary length problem is PSPACE-complete by a result of Jerrum.

Tue 22 SeptComputational Complexity
The gist
This paper looks at how hard it is to figure out how many steps it takes to build every element of a certain mathematical group from given basic pieces. The authors show that deciding whether every element can be formed with a limited number of steps is very complicated to compute, falling into a high complexity class called PSPACE-complete. For a special kind of groups called 2-step nilpotent groups, the problem has slightly different complexity classifications. This kind of work helps us understand the limits of what computers can efficiently solve in group theory.
Open → 2609.26307v1

Improved ways to find distant vectors from linear subspaces

Improved Algorithms for the Remote Point Problem

Abstract: The Remote Point Problem (RPP) is an algorithmic problem that asks, given a linear subspace $L \subseteq \mathbb{F}^n$ of dimension $k$, to deterministically find a vector $v \in \mathbb{F}^n$ far in Hamming distance from $L$. This problem was introduced by Alon, Panigrahy and Yekhanin [APY09], motivated in part by the matrix rigidity approach for proving circuit lower bounds. An algorithm is said to achieve remoteness $d$ if it finds a vector $v$ whose Hamming distance from $L$ is at least $d$. We observe that over the rational numbers, the problem admits a deterministic polynomial-time algorithm that achieves optimal remoteness $n-k$. Over finite fields, we obtain a (modest) improvement of a result of Alon, Panigrahy and Yekhanin [APY09], and give an algorithm that achieves remoteness $Ω\left(\frac{n}{\max\{k, \log n\}} \log n\right)$.

Tue 22 SeptComputational ComplexityData Structures and Algorithms
The gist
The Remote Point Problem asks how to find a vector that is very different from all vectors in a given linear space. The authors show that over rational numbers, the problem can be solved optimally using a fast algorithm. For vectors over finite fields, they improve previous methods to find vectors that are far away in terms of differing entries. This helps in understanding how to construct hard-to-approximate objects related to computer circuits.
Open → 2609.25765v1

New bounds on the number of equilibria in non-square games

Equilibrium Numbers in Non-Square Bimatrix Games

Abstract: Bimatrix games may have an exponential number of mixed Nash equilibria if both dimensions of the game are allowed to grow. Bounds on their maximal number give structural insights that have been used to construct hard-to-solve games. We show new sharp or asymptotically sharp bounds on the (polynomial) number of equilibria for generic games where one dimension of the game is fixed and the number of strategies of the other player grows. These results go beyond the hitherto studied square games. Our methods employ combinatorial properties of polytopes, and recent obstructions that relate to the graph of those polytopes. For $n\ge5$, we construct $3\times n$ games that have all $2n+1$ vertices of the best-response polytope as equilibrium strategies, proved using a simple case of the 4-color theorem for planar graphs. Generic $4\times 5$ games are shown to have at most 17 equilibria, using computer calculations with existing datasets for all combinatorial types of the relevant polytopes. For $d\times n$ games, we construct games where all but a fraction of $O(1/n)$ of the maximum number of vertices are equilibrium strategies.

Mon 21 SeptComputer Science and Game Theory
The gist
Games where two players each choose from a list of strategies can have many different 'balance points' called Nash equilibria, where neither player wants to change their choice. Past studies mostly looked at games where both players have the same number of choices, but this paper explores what happens when one player’s choices stay fixed while the other grows. The authors find new sharp limits on how many equilibria can appear in these cases, using math about shapes called polytopes and graph theory ideas. They also provide examples of games that reach these limits and use computer checks to confirm their counts.
Open → 2609.24878v1

Balanced mobiles problem is strongly NP-complete to solve optimally

Strong NP-Completeness of Unrestricted Balanced Mobiles

Abstract: A mobile is a rooted full binary tree whose leaves carry positive integer weights. The imbalance of an internal node is the absolute difference between the total weights of its two child subtrees, and the cost of the mobile is the sum of these imbalances. In the unrestricted \emph{Balanced Mobiles} problem, only the multiset of leaf weights is given: both the tree topology and the placement of the weights must be chosen so as to minimize the cost. The computational complexity of this unrestricted variant has remained open, although the variant with a prescribed topology is strongly NP-hard. We close this gap by proving that the decision version of unrestricted Balanced Mobiles is strongly NP-complete. Our reduction from Numerical 3-Dimensional Matching with Distinct Integers uses three widely separated numerical scales. Tight telescoping bounds force every threshold-achieving mobile into a canonical hierarchy, after which pairwise distinctness of the source integers collapses the hierarchy to single triples from which a valid numerical matching can be recovered.

Mon 21 SeptComputational Complexity
The gist
This paper looks at a problem where you have to build a special kind of tree with weighted leaves to minimize imbalance between parts of the tree. The authors prove that deciding whether you can build such a tree with an imbalance below a certain threshold is very hard computationally (strongly NP-complete). They do this by linking the problem to a known difficult puzzle about matching numbers in triples. This result closes an open question about the problem’s difficulty when you can choose both the tree shape and leaf placement.
Open → 2609.24654v1

Space-efficient derandomization methods for complex branching models

SC Derandomization for Regular ROBPs and Models Beyond BPL

Abstract: We study SC derandomizations for regular read-once branching programs (ROBPs) and computation models beyond BPL. For regular ROBPs with length $n$, width $w$, and multiple accept nodes, we attain three results. 1. When $n \le w$, we show an SC derandomization with space $O(\log^2 n+\log w)$ and error $1/\text{poly}(nw)$. 2. When $n \ge w$, we show an SC derandomization with space $O(\log n \log w)$ and error $1/\text{poly}(w)$. 3. When $w=O(\log n)$, we show an optimal $O(\log n)$ space derandomization with error $1/\text{poly}(w)$. We further show that two super sets of BPL can be computed in SC. 1. For probabilistic logspace TMs with a two-way access random tape, we show that it can be approximated in SC if each entry of the random tape is accessed for at most a constant number of times. 2. For probabilistic logspace TMs with a polynomial size stack, i.e. probabilistic logspace Auxiliary Push-down Machines (AuxPDMs), we show that it can be approximated in SC if the timings of push/pop/idle stack operations do not depend on the randomness. The first model is the read-multiplicity model considered by Impagliazzo, Nisan, Wigderson (STOC'94), in which they show that their INW generator can fool such computations. For the second model, we indicate that it contains candidate languages separating BQL from BPL considered by Apers and Edenhofer (CCC'25).

Sun 20 SeptComputational Complexity
The gist
Derandomization is a way to make random processes in computing more predictable, using less memory space. This paper improves how computers can simulate random tests for certain structured programs called regular read-once branching programs, using very little memory. The authors also extend these methods to more powerful models that use randomness and memory in special ways, showing they can still be simplified without losing accuracy. These results help better understand the limits of efficient computation with randomness.
Open → 2609.23603v1

Complexity of interval numbers in tournament graph convexities analyzed

Interval number for tournaments in P3-convexity

Abstract: We study the complexity of determining the interval numbers of tournaments in the $\overrightarrow{P_3}$ and $\overrightarrow{P_3^*}$ convexities, denoted by $\overrightarrow{\mathrm{in}}_{P_3}(T)$ and $\overrightarrow{\mathrm{in}}_{P_3^*}(T)$ on a tournament $T$. For each $\overrightarrow{\mathcal{X}} \in \{\overrightarrow{P_3}, \overrightarrow{P_3^*}\}$, we show that determining whether $\overrightarrow{\mathrm{in}}_{\mathcal{X}}(T) \leq k$ is W[2]-complete when parameterized by $k$. Moreover, under ETH, we show that there is no parameterized algorithm for that problem with running time $f(k)\, n^{o(k)}$ on an $n$-vertex tournament, where $f$ is any computable function. For the $\overrightarrow{P_3}$-convexity, we also show that $\overrightarrow{\mathrm{in}}_{P_3}(T) = \mathcal{O}(\log n)$, which yields a simple quasi-polynomial $n^{\mathcal{O}(\log n)}$ brute-force algorithm. On the other hand, under ETH, we show that the problem is NP-intermediate, that is, it is neither NP-hard nor in P. For the $\overrightarrow{P_3^*}$-convexity, the same brute force algorithm is not quasi-polynomial, since we present a family of instances with $\overrightarrow{\mathrm{in}}_{P_3^*}(T) = Θ(n)$. We conjecture that this problem is NP-complete.

Fri 18 SeptComputational Complexity
The gist
This paper looks at how hard it is to find certain 'interval numbers' in special networks called tournaments. The authors study two types of these interval numbers and find that deciding if these numbers are below a certain value is very computationally tough. They prove that no fast algorithm is likely to exist for these problems unless certain common assumptions in computer science fail. They also identify cases where some quick approaches are possible and others where the problem remains difficult and not fully classified.
Open → 2609.22640v1

Exact minimal multiplications found for specific small matrix product

A lower bound for $\langle 3,2,m \rangle$ matrix multiplication

Abstract: We prove that, over any field, the bilinear complexity of multiplying a $3\times 2$ matrix by a $2\times m$ matrix is strictly greater than $24m/5$. In particular, every exact bilinear algorithm for multiplying a $3\times 2$ matrix by a $2\times 5$ matrix requires at least $25$ multiplications. Together with the Hopcroft-Kerr upper bound, this proves that the $\langle 3,2,5\rangle$ matrix multiplication tensor has rank exactly $25$. The proof has been formally verified in Lean 4, with the formalization available at https://github.com/fallnlove/mm325_proof.

Fri 18 SeptComputational ComplexityData Structures and Algorithms
The gist
Figuring out the smallest number of multiplications needed to multiply matrices is important for speeding up calculations in many computer programs. The authors proved the exact minimum number of multiplications needed to multiply a 3-by-2 matrix by a 2-by-5 matrix, showing it cannot be done with fewer than 25 multiplications. This matches a previously known upper limit, so the exact minimal cost is now known. They also double-checked their proof using computer verification to ensure it is correct.
Open → 2609.22054v1

Single-loop methods improve complex nonconvex concave optimization tasks

Single-Loop Stochastic Projected Damped Extragradient Methods for Stochastic Nonconvex--(Strongly) Concave Minimax Optimization

Abstract: We develop single-loop stochastic projected damped extragradient methods for stochastic nonconvex--(strongly) concave minimax optimization, with complexity guarantees for both game stationarity (GS) and optimization stationarity (OS). Our approach combines a stochastic projected damped extragradient (SPDE) method with a recursive variance-reduced variant, VR-SPDE, both of which retain a single-loop structure. Under an unbiased stochastic gradient oracle with uniformly bounded variance, SPDE finds an $\varepsilon$-game-stationary point with stochastic first-order oracle (SFO) complexities of $O(κ\varepsilon^{-4})$ and $O(\varepsilon^{-5})$ in the nonconvex--strongly concave and nonconvex--concave settings, respectively, where $κ=L/μ$. Under an additional mean-square Lipschitz condition on the stochastic gradients, VR-SPDE improves these GS complexities to $O(κ^{3/2}\varepsilon^{-3})$ and $O(\varepsilon^{-9/2})$, respectively. For an $\varepsilon$-optimization-stationary point, SPDE achieves SFO complexities of $O(κ\varepsilon^{-4})$ and $O(\varepsilon^{-6})$, while VR-SPDE achieves $O(κ^{3/2}\varepsilon^{-3})$ and $O(\varepsilon^{-6})$, in the two settings, respectively. These OS guarantees match the best-known bounds achieved by multi-loop methods while preserving a single-loop implementation. To the best of our knowledge, our results provide the best-known SFO complexity guarantees among single-loop stochastic first-order methods for the respective stationarity criteria and problem classes.

Fri 18 SeptMachine Learning
The gist
This paper looks at tough mathematical problems where two sides try to optimize opposite goals, like in some AI games or training scenarios. The authors design simple, single-loop algorithms that find good solutions faster and with fewer steps than before, while handling noisy or unpredictable data. These methods improve efficiency without adding extra complicated layers, which can help make these problems easier to solve in practice. The authors provide math-based guarantees showing these are among the best methods for this kind of problem.
Open → 2609.21747v1

Simple framework connects swapping actions to adapting over time

From Switching to Dynamic Regret: A Simple Reduction via Unbiased Random Sequences

Abstract: In non-stationary online learning, dynamic regret has attracted increasing attention as a measure of how well an online learner performs against a time-varying comparator sequence. Despite considerable advances, attaining optimal bounds for strongly convex and exp-concave losses often involves intricate analysis. In this paper, we present a \textit{simple} framework that reduces dynamic regret minimization to switching regret minimization. As a result, we can derive dynamic regret bounds by using off-the-shelf algorithms with switching regret guarantees. The key idea of our reduction is to construct, for \textit{any} comparator sequence, an auxiliary random sequence that is unbiased at each round, with the controlled variance and a manageable number of switches. Combining this construction with suitable surrogate losses, we can decompose dynamic regret into the expected switching regret against the random sequence and its controlled variance. Theoretically, for strongly convex and exp-concave losses, we establish the $\widetilde{O}(T^{1/3}P_T^{2/3})$ dynamic regret bounds, where $T$ denotes the time horizon and $P_T$ denotes the path-length of the comparator sequence. Moreover, for general convex losses, the same reduction also recovers the $O(\sqrt{T(1+P_T)})$ dynamic regret bound. Notably, all our findings match the minimax optimal results for these three types of losses, highlighting the versatility of our proposed framework.

Thu 17 SeptMachine Learning
The gist
When learning from changing situations over time, it's hard to perform as well as a moving target. The paper shows how to translate the challenge of adapting to many changes into the easier problem of handling a few switches. The authors introduce a way to create a random sequence that mimics the changing target but only switches a few times with controlled randomness. This connection lets existing methods solve dynamic challenges more simply and with proven optimal performance.
Open → 2609.20968v1

Improved convergence rates for nonsmooth convex optimization over small sets

The First-Order Oracle Complexity of Lipschitz Convex Optimization in Nondual Settings

Abstract: We study first-order black-box convex optimization over an $\ell_p$-ball for objectives Lipschitz in the $\ell_q$-norm, solving in the affirmative the nonsmooth version of the COLT open question (Guz15b) on whether the geometry of a smaller feasible set ($p < q$) can improve convergence rates in convex optimization, and matching prior lower bounds up to logarithmic factors. Our rates include \(\widetilde O(1/T)\) for convex Euclidean-Lipschitz optimization over the $\ell_1$-ball, improving on the $O(1/\sqrt{T})$ classical rate under general assumptions. The key technical device is a new online learning game, where the comparator is evaluated using the maximum of affine losses observed so far. We bound the value of this game above and below in terms of a combinatorial online learning quantity: the sequential fat-shattering dimension, which we characterize for the $\ell_p / \ell_q$ case. Our results generally apply when the feasible set $X$ and the set of possible subgradients $H$ are convex, centrally symmetric, and admit a type of minmax theorem, advancing on a fundamental question by Sridharan [Sri12, Section 10.1.2, Q3]. As a geometric consequence of our analysis, of independent interest, we obtain estimates for the expected distance of a convex hull of samples to their mean in several Banach geometries, a version of the celebrated Wendel's theorem (Wen62), but quantitative and for bounded general distributions as opposed to centrally symmetric ones.

Thu 17 SeptMachine Learning
The gist
This paper studies how quickly certain optimization problems can be solved when working with shapes (called balls) defined by different distance rules. The authors show that if the set you're searching over is smaller in a certain sense, you can find solutions faster than previously known. They develop a new mathematical game to prove this and connect it to ideas in online learning and geometry. Their results improve on classical limits for how fast optimization algorithms can work in these settings.
Open → 2609.20687v1

Information theory sets limits on randomized online set cover

An $\tilde Ω(\log n \log m)$ Information-Theoretic Lower Bound for Randomized Online Set Cover

Abstract: We show an information-theoretic lower bound of $Ω\left(\frac{\log n \log m}{\log \log n + \log \log m}\right)$ for online set cover against randomized algorithms, for all sufficiently large $m$ and $n$ satisfying $\log^2 n \leq m \leq 2^n$.

Thu 17 SeptData Structures and Algorithms
The gist
The paper finds a new mathematical lower bound on the difficulty of a problem called online set cover, where elements need to be covered by sets that are chosen one by one without knowing future items. The authors show that any randomized method for this problem must use at least a certain amount of information, specifically on the order of logarithms of the number of elements and sets. This means there is a fundamental limit on how efficiently these problems can be solved in an online setting. The result holds under broad conditions on the number of elements and sets involved.
Open → 2609.20610v1

Integral polytopes clarify rank problems in symbolic matrices

On integral polytopes related to Edmonds' problem

Abstract: In this paper, we study polyhedral aspects on commutative and noncommutative Edmonds' problems for computing the rank of linear symbolic matrix $A = \sum_{k=1}^m A_k x_k$. We regard them as linear optimization over integral polytopes ${\cal P}(A)$ and ${\cal Q}(A)$, respectively, which are obtained by the convex hulls of exponent vectors of subdeterminants of~$A$ and its blow-ups $A^{\{d\}} = \sum_{k=1}^m A_k \otimes X_k$ $(d=1,2,\ldots)$. By extending previously known results on nc-rank, we establish a hierarchy of integral polytopes ${\cal P}(A) \subseteq {\cal P}^{\leq 2}(A) \subseteq {\cal P}^{\leq 3}(A) \subseteq \cdots = {\cal Q}(A)$ and show that the integrality gap of ${\cal Q}(A)$ relative to ${\cal P}(A)$ is at least $1/2$. Further, we show that if each $A_k$ is rank-2 skew-symmetric, then the above hierarchy terminates at the second level and the integrality gap is improved to $2/3$.

Thu 17 SeptDiscrete Mathematics
The gist
This paper looks at how to better understand the rank of certain symbolic matrices, which are matrices with variables instead of fixed numbers. The authors study geometric shapes called polytopes that represent these matrices in two different ways, one connected to normal matrices and another to a more complex, 'noncommutative' version. They reveal a sequence of polytopes that bridge these two versions and measure how different they can be from each other. For special types of matrices built from rank-2 skew-symmetric blocks, they find the sequence stops early and the difference is smaller.
Open → 2609.19703v1

Parameter hardness limits approximation of k-SetCover problems

Almost Optimal FPT Inapproximability for k-SetCover

Abstract: We show that $\bigl(\frac{\log n}{\log\log n}\bigr)$-approximate parameterized $k$-SetCover is W[1]-hard, and has no $n^{o(k/\log k)}$-time algorithms under ETH. This improves upon the previous best factors $\bigl(\frac{\log n}{\log\log n}\bigr)^{1/k}$ in (Lin, 2019) and $(\log n)^{1/\operatorname{poly}(k)}$ in (Karthik, Laekhanukit, and Manurangsi, 2019). Here $k$ is the yes-case guarantee and $n$ is the number of candidate sets. While the best approximation ratio is still $O(\log n)$ via the greedy algorithm, closing this $1/k$ gap in the exponent has been a longstanding open problem; we remove this loss via a simple direct reduction. The construction is self-contained and does not rely on the parameterized inapproximability hypothesis (PIH). Starting with sparse parameterized 2-CSP instances (Karthik, Marx, Pilipczuk, and Souza, 2024), we build a monotone CNF formula, which is equivalent to a SetCover instance. To obtain a $k$-versus-$h$ gap, the reduction enumerates all hash functions from $Σ$ to $[2h]$ and all unsatisfiable 2-CSP instances on the same constraint graph with alphabet $[2h]$. For each such instance, it asks for a certificate that the hashed label pairs are not all contained in that instance. Perfect hashing makes this enumeration efficient for $h=\log n/\log\log n$.

Thu 17 SeptComputational ComplexityData Structures and Algorithms
The gist
Covering problems ask how to pick the smallest number of groups to include all items. The paper finds nearly the best possible difficulty level for a version where you want to cover using exactly k groups. The authors improve older results by showing you can't efficiently get very close to the best solution when k is a parameter. They use clever logical formulas and hash functions to prove this hardness without relying on previous assumptions. This helps clarify how hard it really is to approximate these problems quickly.
Open → 2609.19685v1

Set cover problem hard to approximate within near logarithmic factor

Near-Logarithmic Inapproximability of Parameterized Set Cover

Abstract: We study the approximability of \textnormal{\textsc{Set Cover}} parameterized by the target cover size $k$. Let $n$ be the universe size, $m$ the number of available sets, and $|Γ|$ the explicit input length. We prove that, for some absolute constant $c>0$, distinguishing \[ \operatorname{opt}(Γ)\le k \quad\text{from}\quad \operatorname{opt}(Γ)>k\cdot\frac{c\log n}{k^2\log\log n} \] is $\mathsf{W[1]}$-hard. Assuming the Exponential Time Hypothesis, there is also an absolute constant $\varepsilon>0$ for which no deterministic algorithm solves this gap problem in time $f(k)|Γ|^{\varepsilon k}$, for any computable function $f$. For every fixed $α>0$, both hardness results hold even when $n=O((\log m)^{1+α})$, with constants allowed to depend on $α$. For fixed $k$, the gap is within an $O_k(\log\log n)$ factor of the greedy algorithm's guarantee. Under the Strong Exponential Time Hypothesis, we further rule out $o(\log n/\log\log n)$ approximation in time $O(|Γ|^{k-δ})$ for every fixed $k\ge 2$ and $δ>0$. Thus a near-logarithmic hardness factor persists even when the exponent is reduced from exhaustive search by only a fixed constant. The constant in this SETH hardness factor may depend on $k$ and $δ$.

Thu 17 SeptComputational Complexity
The gist
The set cover problem asks how to cover a universe of items using as few sets as possible. The authors show it is very hard to find a close approximation of the smallest number of sets when looking for a cover of size k. They prove that even allowing some slack, no fast algorithm can reliably distinguish small covers from much larger covers. This holds true even with some strong complexity assumptions, meaning that efficient algorithms can only get so close to the best solution. Their findings set limits on how well algorithms can perform on this problem.
Open → 2609.19623v1

Spectral gap analysis simplified for better Markov chain estimates

Spectral Gap of Down-Up Walks via Trickle-Down: A Simplified and Sharpened Analysis

Abstract: Local-to-global techniques for establishing spectral gaps have played a central role in the modern theory of Markov chain mixing times and the theory of high-dimensional expanders. One of the most striking results in this burgeoning literature is that a spectral gap for the global down-up walk on the facets of a pure simplicial complex can be reduced to sufficiently strong spectral expansion of just the codimension-2 links of the complex, a phenomenon colloquially referred to as "trickle-down". These types of theorems have had many important applications, including rapid mixing of the exchange walk on the bases of any matroid. In this primarily expository article, we give streamlined proofs of two such theorems in the literature, one by Oppenheim (2018) and one by Leake and Oveis Gharan (2025), via an integrated Bochner method. Moreover, in the latter setting, we quantitatively strengthen the dependence of the global spectral gap on the dimension of the complex and the spectral influence, resolving an open question of Leake and Oveis Gharan. Disclaimer: The proofs were developed through a couple of rounds of interaction with GPT-5.6 Sol Ultra. We later discovered that Guo and Zhang (2026) had independently proven the same strengthening of the trickle-down theorem of Leake and Oveis Gharan using an extremely similar argument, also found by GPT-5.6 Sol Ultra. The focus of their paper is the complexity of approximating the partition function of spin systems on planar graphs, not on the trickle-down phenomenon itself. In contrast, our motivation is primarily expository, and we hope to bring Bochner-type methods and their connections with the trickle-down phenomenon to the attention of a wider community of researchers.

Thu 17 SeptData Structures and AlgorithmsDiscrete Mathematics
The gist
This paper explains a way to understand how quickly certain random processes, called down-up walks, mix or become random enough. The authors focus on a technique called trickle-down, which shows that knowing something about smaller parts of a structure helps predict behavior of the whole. They provide clearer proofs and improve earlier results by linking spectral gaps to properties of these smaller parts. Their work is meant to help more people learn about these mathematical tools, especially using a method called the Bochner method.
Open → 2609.19514v1

Matrix multiplication over fields needs at least 21 terms

A Structural Proof of the Lower Bound 21 for $3\times3$ Matrix Multiplication over $\mathbb F_2$

Abstract: We prove that the tensor rank of $3\times3$ matrix multiplication over $\mathbb F_2$ is at least $21$. The structural proof, independently developed by Qiushi Engine, converts occupation constraints on a single tensor factor into algebraic relations coupling all three factors. Certified quotient-rank bounds and finite geometry force any hypothetical $20$-term decomposition to have first-factor matrix-rank profile $(16,1,3)$. The ranks of the corresponding split-flattened summands therefore sum to $27$, exactly the rank of the full split flattening. Equality in rank subadditivity forces their images to form a direct sum; normalization by the inverse flattening then makes the summands pairwise annihilating idempotents. An explicit product identity for matrix multiplication implies that at most one first factor can be invertible, contradicting the three forced by the profile. The same obstruction constrains $22$-term decompositions attaining the split-rank bound. The complete proof, including the finite quotient bounds, is formalized in Lean. The accompanying research trajectory records Qiushi Engine's long-horizon autonomous research, from numerical experiments and quotient constructions to the structural proof.

Wed 16 SeptComputational ComplexityData Structures and AlgorithmsSymbolic Computation
The gist
Multiplying two 3x3 matrices over a simple math system called F2 requires at least 21 basic multiplication steps. The authors prove this by examining how different parts of the multiplication process fit together and using rules from algebra and geometry. They show that trying to do it with only 20 steps leads to logical contradictions. This proves a lower limit on how efficiently this matrix multiplication can be done.
Open → 2609.18722v1

Genome translocation distance proven hard and solvable with fixed parameter

NP-Hardness and a Fixed-Parameter Algorithm for Translocation Distance

Abstract: In this paper we study the genome rearrangements done by translocation events. Genome rearrangements were used to measure evolutionary distance between organisms since 1936 (Dobzhansky and Sturtevant). The chromosomes are represented as strings of DNA and the \emph{translocation operation} is defined as the exchange of prefixes between two strings. This operation results in the creation of two new strings (chromosomes) that can then be utilized in subsequent translocations. A translocation is referred to as \emph{contiguous} if the new strings are produced in a single copy, so each of them can be used in only one subsequent operation. When the words produced by a translocation operation are considered to have an infinite number of copies, the translocation is referred to as \emph{non-contiguous}. If the exchanged prefixes are of equal length, the translocation is called \emph{uniform}. Otherwise, the translocation is termed \emph{non-uniform}. The \emph{translocation distance} between two sets of strings, termed the input set and the target set, represents the minimum number of translocations necessary to obtain all the strings in the target set via translocation operations. We prove that both the non-uniform contiguous and the non-uniform non-contiguous translocation distance problems are NP-hard over arbitrary finite alphabets, where the alphabet is part of the input. For the case in which the target set consists of a single string, we give a fixed-parameter tractable algorithm parameterized by the length of the target string.

Wed 16 SeptData Structures and Algorithms
The gist
This paper studies how we can measure the differences between groups of DNA strings by swapping parts between them, mimicking biological events called translocations. The researchers show that figuring out the smallest number of these swaps needed to get from one set of DNA strings to another is a very hard problem in general. However, when the target is just one DNA string, they provide an efficient algorithm that works well if the target string is not too long. This helps understand the complexity of comparing DNA rearrangements and offers a practical way to solve a special case.
Open → 2609.18397v1

Complexity proved hard for partizan edge geography on undirected graphs

The Complexity of Undirected Partizan Edge Geography

Abstract: Partizan Edge Geography is a two-player game on a graph where each player has their own token on a vertex and moves their token to a neighbor in a turn removing the edge. Two player alternately move their tokens and the first player who cannot move loses the game. Fraenkel and Simonson (TCS, 1993) showed that the winner determination of this game is PSPACE-complete on directed graphs, given a graph and token positions. This paper resolves its complexity on undirected graphs by showing the PSPACE-completeness on bipartite undirected graphs of maximum degree 3. The same reduction also works for a variant where two tokens cannot be placed on the same vertex.

Wed 16 SeptData Structures and Algorithms
The gist
The paper looks at a two-player game played on a graph where players move tokens along edges and remove them after moving. Previously, it was known this game is very hard to solve on directed graphs, meaning figuring out who will win can take a lot of computational effort. The authors show that even when the graph is undirected, simple, and has limited connections, determining the winner remains equally hard. They also show this holds for a version of the game where players cannot share the same spot.
Open → 2609.18330v1

Improved algorithm learns polynomial size depth three circuits faster

Learning Depth-3 Circuits with Polynomial Savings

Abstract: We study the challenging problem of learning depth-three circuits in the mistake-bound model of (realizable) online learning, which is a more difficult model than distribution-free PAC learning. Prior algorithms for this problem, due to Servedio and Tan [ST17], could only learn polynomial-size depth-three circuits of poly$(n)$ size over $\{0,1\}^n$ with a running time of $2^{n - Ω(n/\log n)}$, and hence they ran in time $N^{1-o(1)}$ where $N=2^n$ is the running time of a naive memorization-based approach. In this work we substantially improve on the [ST17] result: for any constant $γ\geq1$, we give an algorithm that learns depth-three circuits of size $n^γ$ with running time \[ 2^{n-c_γn}, \] where $c_γ>0$ depends only on $γ$ and not on $n$. Hence we achieve a polynomial savings over the naive approach for learning any polynomial-size depth-three circuit. The main driving force behind our improvement is an improved bound on the approximate degree of width-$k$ CNFs. Inspired by Szegedy [Sze04] and Magniez et al. [MNRS11], the rough idea of our construction is to use a Chebyshev polynomial to efficiently amplify the spectral gap of a carefully designed random walk. This is combined with a random-restriction-like approach to separately learn different subfunctions corresponding to different assignments to a randomly chosen set of variables, using the Perceptron algorithm over a specially designed feature space. A simplified warmup instantiation of our approach achieves $c_γ= \exp(-O(γ))$; by augmenting this warmup with further ingredients we obtain the sharp form of our result, which achieves $c_γ=Ω(1)/γ$.

Wed 16 SeptData Structures and AlgorithmsComputational Complexity
The gist
Learning certain types of logical functions called depth-three circuits is a hard problem in computer science. The authors present a new algorithm that can learn these functions faster than previous methods, saving significant computing time. They achieve this by using advanced math techniques involving random walks and special polynomials to better approximate parts of the function. This improvement means more efficient learning of complex functions on binary inputs.
Open → 2609.18166v1

New tight bounds reveal limits of algebraic communication tasks

Tight Lower Bounds for Algebraic Communication and Applications

Abstract: Communication complexity studies how much information must be exchanged to solve a problem whose input is split among several parties. The classical setting deals with Boolean inputs split between two parties. We study an algebraic variant, where the inputs are vectors over a field $\mathbb{F} \in \{\mathbb{R}, \mathbb{C}\}$. Alice and Bob have inputs $X\in \mathbb{F}^n$ and $Y\in \mathbb{F}^n$, respectively. We consider two kinds of tasks: the polynomial evaluation problem (compute the value of a polynomial $g\in \mathbb{F}[X,Y]$), and the set-recognition problem (decide whether (X,Y) is in $S$, for $S\subseteq \mathbb{F}^{n} \times \mathbb{F}^n$). In both settings, Alice and Bob send evaluations of polynomials depending only on their own inputs. In the set-recognition problem, a referee receives the messages and may apply polynomial tests to the messages received so far; the outcomes of these tests determine acceptance or rejection. The protocols may be deterministic or probabilistic. We study: - Upper bounds and reductions: We give non-trivial upper bounds for a range of natural polynomial evaluation and set-recognition problems and prove reductions between different problems, which help organize the landscape of the model. - A lower bound framework and tight lower bounds: Our main technical contribution is a general framework for proving lower bounds for algebraic set-recognition problems. We prove several probabilistic lower bounds for natural problems, giving tight or near-tight characterizations of their algebraic communication. - Applications of the framework: Finally, we give two applications of our framework: proving lower bounds for a class of left-to-right algebraic algorithms (algebraic scanners) and a more general algebraic computational setting inspired by the BSS model.

Tue 15 SeptComputational Complexity
The gist
This work studies how two people can share information efficiently when given parts of a problem expressed as numbers rather than simple yes/no answers. The authors look at how much communication it takes to evaluate polynomial functions or decide if certain conditions are met based on their separate inputs. They provide methods to prove the smallest amount of information that must be exchanged in different scenarios, and show how these results apply to certain algebra-based algorithms. Their framework deepens understanding of communication limits in mathematical computation tasks.
Open → 2609.17082v1

Local-global principles advance understanding of zeros in recurrence sequences

Twisted Rational Zeros and Local-Global Principles for Linear Recurrence Sequences

Abstract: The Skolem Problem asks whether a given linear recurrence sequence (LRS) has a zero term, and is equivalent to proving an effective version of the Skolem-Mahler-Lech theorem, which states that a non-degenerate LRS has finitely many zeros. Decidability of the Skolem Problem however, has remained open for many decades. Bilu et al. (2022) showed that the Skolem Problem for simple LRS is decidable subject to the weak $p$-adic Schanuel Conjecture and the Skolem Conjecture (also known as the exponential local-global principle), the latter of which states that an LRS has an integer zero if and only if it has a zero modulo every integer $m$. This paper works towards understanding the Skolem Conjecture. We provide an example showing that a natural strengthening of the Skolem Conjecture, where we restrict $m$ to be a prime power, is false. This failure is accounted for by the relationship between $p$-adic zeros of LRS (which arise naturally in the proof of the Skolem--Mahler--Lech theorem and have been studied algorithmically by Bacik et al. (2026)) and twisted rational zeros (introduced by Bilu et al. (2025)). By studying this relationship further, we are able to prove the main result of this paper: a local-global principle for simultaneous zeros of two coprime LRS, subject to the $p$-adic Schanuel Conjecture. A fundamental step in proving this result is characterising when twisted rational zeros are (or are not) $p$-adic zeros for infinitely many primes $p$, which we do unconditionally. This also answers two open questions of Bilu et al. (2025). Finally, we conjecture that the existence of twisted rational zeros is the only way that the aforementioned strengthened Skolem Conjecture may fail, which is supported by a heuristic argument.

Mon 14 SeptFormal Languages and Automata Theory
The gist
This paper looks at a long-standing math puzzle called the Skolem Problem, which asks whether a repeating list of numbers ever hits zero. The authors explore why a common way of checking for zeros by looking at prime powers doesn't always work. They uncover deeper links between certain special zeros and zeros in different number systems, leading to new rules that can predict when two sequences will both be zero at the same time. Their work also answers some previous open questions and proposes that these special zeros explain all the recent puzzles.
Open → 2609.16392v1

Improved limits for fair division of indivisible items among agents

Improved Impossibility Bounds for Maximin Share Allocations

Abstract: The maximin share (MMS) is a central fairness benchmark for allocating indivisible items, but it need not be simultaneously attainable even under additive preferences. While extensive work has developed approximation guarantees, quantitative impossibility bounds have received comparatively little attention. We establish improved asymptotic and constant impossibility bounds for both goods and chores. For every sufficiently large number $n$ of agents, we construct additive goods instances in which every allocation gives some agent at most a $1-Ω((\log n)^{-2})$ fraction of her MMS. This strengthens the $1/n^4$ shortfall of Feige, Sapir, and Tauber (2021) to an inverse-polylogarithmic shortfall, an exponential improvement on the logarithmic scale of $n$. For chores, we construct instances in which every allocation gives some agent cost at least a $1+Ω((\log n)^{-2})$ factor of her MMS. Consequently, for every fixed $\varepsilon>0$, guarantees of $1-O(n^{-\varepsilon})$ for goods and $1+O(n^{-\varepsilon})$ for chores are impossible. We also give four-agent, eleven-item instances that improve the universal impossibility bounds from $39/40$ to $20/21$ for goods and from $44/43$ to $31/30$ for chores.

Mon 14 SeptComputer Science and Game Theory
The gist
Fairly dividing indivisible items among many people is tricky because sometimes no perfect solution exists. This paper shows stronger mathematical limits on how close any allocation can get to a fair benchmark called maximin share (MMS) for both desirable items (goods) and undesirable tasks (chores). The authors demonstrate that as the number of people grows, the shortfall from perfect fairness worsens in a specific, predictable way. They also improve exact bounds for smaller cases with four people and eleven items.
Open → 2609.15085v1

Randomized queries can be far more efficient than certificates

Randomized query complexity can beat certificate complexity

Abstract: A long-standing open question in query complexity asks whether there is a total Boolean function f with R(f) << C(f), where R(f) and C(f) denote its bounded-error randomized query complexity and certificate complexity, respectively. We construct a function with R(f) = O~(sqrt{C(f)}), which is optimal up to log factors. The same function also has $Q(f) = O~(C(f)^{1/4}), where Q(f) is the bounded-error quantum query complexity of f, which is also nearly optimal.

Mon 14 SeptComputational Complexity
The gist
Sometimes, figuring out the answer to a problem can involve checking just a few crucial hints, called certificates, or asking questions randomly. The authors created a special function where randomly asking questions is much faster than relying on certificates alone. This means random strategies can be significantly more efficient at solving some problems. Their method is also nearly the best possible compared to previous approaches.
Open → 2609.15063v1

Exact growth rate found for minimal space reversible pebbling

The Exact Growth Rate of Space-Optimal Reversible Pebbling on Chains

Abstract: We determine the exact time exponent of space-optimal reversible pebbling on chains as $1.331742379256310\ldots$. The growth rate of space-optimal reach exists as a limit and admits a variational formula. The same exponent governs complete computations at minimal space, uniformly in the chain length.

Mon 14 SeptComputational Complexity
The gist
The paper finds the exact speed at which a specific computational process, called reversible pebbling on chains, grows over time when using the least possible memory space. The authors show this growth follows a precise number (about 1.33) that also applies uniformly for all chain lengths. This clarifies how efficiently a certain minimal memory computation can be performed and proves a formula that describes this growth rate.
Open → 2609.15062v1

Online balancing of sparse random vectors has a sharp complexity threshold

The threshold for online balancing of i.i.d. binary vectors

Abstract: Consider the task of online vector balancing for stochastic arrivals $X_1,\ldots,{X_T}$, where the $X_i$ are independent uniformly random $d$--sparse binary vectors in $\{0,1\}^n$. This is a random analogue of the online Beck--Fiala problem. We show that uniformly for $2\le d\le n/2$ and $T = Θ(n)$, the optimal online prefix discrepancy $\max\limits_{t\leq T}\left\|\sum_{i=1}^tσ_i X_i\right\|_\infty$ is of order \[ Θ\big(\max\{\sqrt d,\log\log n\}\big). \] The upper bound is achieved by an efficient online algorithm. Thus, for $d\le(\log\log n)^2$, the optimal discrepancy is $Θ(\log\log n)$ and is independent of the sparsity up to constant factors, whereas above this scale it is $Θ(\sqrt d)$, matching the order of the offline discrepancy. This identifies the threshold at which sparsity begins to govern the online discrepancy of the random Beck--Fiala model.

Mon 14 SeptData Structures and Algorithms
The gist
The paper studies how well an online algorithm can balance sequences of randomly arriving binary vectors with a certain number of ones. The authors found a precise threshold where the difficulty of the problem changes significantly depending on how many ones each vector has. If the vectors are very sparse, the challenge depends on a slow-growing function of the vector size; if they are less sparse, it depends on the square root of the number of ones. The study includes an efficient algorithm achieving the best possible balance.
Open → 2609.14975v1

Lower bounds established for tensor rank in specific matrix multiplication

New lower bounds on tensor rank of $(2,n,m)$ matrix multiplication with GPT-6

Abstract: The tensor rank of $2\times n$-with-$n\times m$ matrix multiplication is at least $(n+2)m$ if $n\ge 4$ and at least $\left\lceil \frac{24}{5}m \right\rceil$ if $n=3$. Both lower bounds apply over arbitrary fields.

Sun 13 SeptComputational Complexity
The gist
Matrix multiplication is a basic math operation used in many computer algorithms, and understanding its complexity helps improve computing efficiency. The authors studied how complicated multiplying a 2-by-n matrix with an n-by-m matrix can get, measured by a concept called tensor rank. They found new minimum complexity levels for this multiplication kind, providing stronger limits than before, applicable for any field of numbers. This helps clarify how hard the problem really is in general.
Open → 2609.14393v1

Complexity of finding fixed points for set-valued contractions proved

On the Complexity of Finding Fixed Points for Set-Valued Contractions

Abstract: In this paper, we study the computational complexity of finding fixed points for set-valued contractions. We first formulate a computational problem for Nadler's fixed-point theorem: Projected-Nadler, and prove that it is $\mathsf{CLS}$-complete by showing its equivalence to Continuous-LocalOpt. We then establish a stronger converse for Nadler's fixed point theorem that can be applied as a tool to analyze the convergence rate of set-valued basic iteration procedure. Finally, we reduce large-margin triplet stationarity problem to Projected-Nadler. Together with its $\mathsf{CLS}$-hardness introduced in [arXiv:2509.16898], this yields $\mathsf{CLS}$-completeness of large-margin triplet stationarity.

Sat 12 SeptComputational Complexity
The gist
Finding fixed points—values that stay the same after applying a certain function—is important but can be tricky, especially when the function can output many values instead of just one. The authors study how hard it is for computers to find these fixed points in such cases. They show this problem is as hard as certain well-known computational tasks classified in the CLS complexity class. They also connect this finding to a specific problem in machine learning called large-margin triplet stationarity, proving it has the same computational difficulty.
Open → 2609.14101v1

Local uniqueness barriers found for complex 48-term matrix multiplication method

Certified local rank and uniqueness barriers for a 48-term matrix-multiplication decomposition

Abstract: We study replacements in fixed bilinear tensor decompositions, counting changes to complete rank-one summands, including output factors. The shortening frontier records the maximum rank defect of a fixed-size subset and determines the minimum length attainable within a change budget. For the rational 48-term Li--Wang--Hu decomposition \(D(2)\) of \(4\times4\) matrix multiplication over \(\mathbb{C}\), we prove rank radius at least 12, strong radius exactly 11, and border radius at least 8. Every shorter complex decomposition therefore changes at least thirteen original summands. An exact rational twelve-term replacement attains the equal-length barrier. The proofs combine exhaustive support reductions with saturated projected kernels and zero-corner completion arguments controlling arbitrary minimal competitors. A reduced-incidence argument transfers kernel certificates to tensor-space neighborhoods. A Laurent normal form gives strong radius exactly 11 for the sixteen-term core at every nonzero complex parameter. On a nonempty Zariski-open subset of the actual parameter curve, the rank radius is at least 12, the strong radius exactly 11, and the border radius at least 8. We also prove incomparability of the full Kothari--Moitra--Wein sufficient criterion and the Sylvester-equipped kernel criterion. These results describe local decomposition structure rather than a new rank bound for full matrix multiplication.

Fri 11 SeptSymbolic ComputationComputational Complexity
The gist
Matrix multiplication can be done in different ways using simpler building blocks, and researchers are interested in the smallest number of these blocks needed. This study looks closely at a known 48-part method for multiplying 4x4 matrices and shows that to find a shorter method, you would have to change many of these parts at once. The authors provide exact measures of how flexible the method is around this known decomposition, meaning any change to use fewer parts faces big barriers. Their work helps understand how unique and stable this matrix multiplication method is on a technical level.
Open → 2609.13596v1

Positive p-energy can decrease when edges are added to graphs

Edge-addition monotonicity of positive p-energy fails for every p >= 1

Abstract: At a 2021 AIM workshop, Guo conjectured that the positive square energy s+ = E+_2 should inherit the familiar edge-addition monotonicity of the spectral radius, rho(G + uv) >= rho(G). That conjecture was subsequently shown to fail at p = 2. Tang, Liu, and Wang then introduced positive p-energy, proved nonmonotonicity for every 1 <= p < 3, and in version 3 of their preprint (26 March 2025) explicitly conjectured that monotonicity should hold for p >= 3. We disprove this conjectured high-exponent extension completely: for every real p > 2 there are infinitely many connected graphs G and nonedges uv such that E+_p(G + uv) < E+_p(G). Together with the Tang-Liu-Wang counterexamples below 3, this shows that no exponent p >= 1 restores the spectral-radius-style monotonicity: positive p-energy can decrease under the addition of an edge for every real p >= 1. The construction is a chain of clique blocks joined by regular bipartite graphs. An equitable quotient converges to Q = I + cA(P_k). For noninteger p, a binomial-series sign argument for a fractional power of I - cA(P_k) gives the required negative endpoint entry. At integer exponents, choosing c across the first spectral threshold leaves exactly one negative eigenvalue, and path locality forces the positive spectral contribution to have negative sign. We also give a fully rational 38-vertex certificate at p = 4 and determine the complete failure interval of a fixed 17-vertex counterexample at p = 3.

Fri 11 SeptArtificial Intelligence
The gist
The paper studies a mathematical measure called positive p-energy on graphs, which are like networks made of points and connections. People thought that adding an edge (connection) to a graph would always increase this measure, as it does for some related concepts. The authors show that for every number p greater than or equal to 1, adding an edge can actually make the positive p-energy go down, disproving previous guesses. They construct specific graphs to prove this and provide concrete examples to illustrate their findings.
Open → 2609.13476v1

Information equivalence simplifies decision tree size and success rates

The Information Complexity of Decision Trees

Abstract: We define and study a measure of information complexity for randomized decision trees. We prove three main results about this complexity measure: Information equals amortized size complexity. We show that the information complexity of randomized decision tree is equal to the logarithm of the amortized worst-case randomized tree size complexity of computing a function f. That is, when computing f on n inputs, the logarithm of the randomized tree size is exactly equal to the amount of information needed to compute the function. Information allows for tree size compression. We show that even when computing f on a single input, the information complexity can be used to compress the size of a tree, if we allow a small loss in success probability. With the recent characterization of Chattopadhyay, Dahiya, Mande, Radhakrishnan, and Sanyal (2023), this result shows that the depth of AND-OR trees can also be compressed in terms of information complexity. Direct Product Theorems. We show that the success-conditioned variant of information complexity satisfies a perfect direct product theorem. This result gives an information complexity analogue of the direct product theorem for success-conditioned randomized query complexity by Ben-David and Blais (2025).

Thu 10 SeptComputational Complexity
The gist
Decision trees are a way computers make choices step-by-step. The authors studied how much information is really needed to make these decisions when randomness is involved. They found that the information needed matches exactly how big the tree must be when solving many problems at once. Their work also shows you can make decision trees smaller if you accept a small chance of error. Additionally, they proved a property that helps understand how solving many problems together affects information needs.
Open → 2609.12164v1

Max independent set complexity stays hard without planar induced minors

Max Independent Set Remains NP-hard when Excluding a Planar Induced Minor

Abstract: We show that there is a fixed planar graph $H$, namely the $5 \times 5$ grid, such that Max Independent Set remains NP-hard in $H$-induced-minor-free graphs. This refutes the Dallard--Milanič--Štorgel conjecture and a weakening of it by Gartland and Lokshtanov, and by Korhonen.

Thu 10 SeptComputational ComplexityDiscrete MathematicsData Structures and Algorithms
The gist
The paper shows that finding the largest group of points in a network with no connections between them (called a maximum independent set) remains a very hard problem even in networks that exclude a certain kind of planar substructure. Specifically, the authors prove this is true even when the network does not have any induced minors that look like a 5 by 5 grid. This result disproves earlier guesses that the problem would become easier in such restricted networks.
Open → 2609.11285v1

Holant problems with four-variable signatures get complexity classification

The Computational Complexity of Holant Problems on 4-regular Graphs from the Stable Subgroup Sequence of $SL(2,\mathbb{C})$

Abstract: The Holant framework provides a general setting for studying counting problems and includes graph homomorphisms (\#GH) and counting constraint satisfaction problems (\#CSP) as special cases. Over the past twenty years, a series of computational complexity dichotomies have been established for Holant problems, but the classification for complex-valued signatures is still open. The main obstacle is the case in which all signatures have even arity. In this paper, we establish a dichotomy for Holant problems with a complex-valued 4-ary signature, which is a key base case for the full classification of Holant problems. We present a new strategy by introducing Schur's theorem, the classification of finite subgroups of $\mathrm{SL}(2,\mathbb{C})$ and stable subgroup sequences into the proof. These new techniques are of independent interest.

Thu 10 SeptComputational Complexity
The gist
Counting certain configurations in networks is a hard problem studied in computer science. The paper focuses on a specific type of such problems called Holant problems that use complex numbers and involve four inputs at each point. The authors solved a key open case by classifying these problems as either easy or hard to compute. They did this by introducing new mathematical tools from group theory, which helps in understanding the problem structure better.
Open → 2609.11175v1

Improved logarithmic bound advances control of vector discrepancy

A $(\log n)^{1/4}$ Bound for the Komlós Problem

Abstract: Let $A\in\mathbb{R}^{m\times n}$ have columns of Euclidean norm at most one. We prove that $\operatorname{disc}(A)\le2395\left(1+\log_+\frac n9\right)^{1/4}+2\sqrt2$. Here $\log_+t=\max\{0,\log t\}$. Building on Bansal and Jiang's affine spectral independence framework, we remove the $(\log\log n)^{7/4}$ factor from their bound. The fourth root comes from balancing the logarithmic decrease in the alive dimension against the fourth power of the row thresholds. Historical exponential sums control the covariance budget across size classes with summable thresholds. An exact threshold-sum certificate gives the coefficient $2395$, and rounding at most eight remaining fractional coordinates costs $2\sqrt2$. The finite construction also gives partial colourings from any prescribed starting point and at any prescribed depth, preserving existing signs. We formalize the partial- and full-colouring theorems in Lean, including the finite trajectory, exact threshold sum and final rounding, with Bansal--Jiang Theorem A.4 as the sole external research theorem assumption.

Tue 8 SeptDiscrete MathematicsData Structures and Algorithms
The gist
This paper finds a better way to balance certain numerical differences in mathematical matrices. The authors show that for matrices whose columns have length at most one, the maximum row discrepancy is smaller than previously proven bounds, specifically limited by a factor tied to the fourth root of a logarithm of the number of columns. They build on prior methods but remove extra terms that made the bounds less tight. Their approach uses a structured balance of thresholds and formal verification to ensure correctness.
Open → 2609.08885v1

Complexity results for recognizing generalized graph search trees

Generalized Graph Search Trees

Abstract: Graph search algorithms and their corresponding graph search trees are commonly used in algorithmic graph theory. In recent years, the recognition problem of these graph search trees has received significant attention. So far, the research has focused on two types of search trees: first-in trees that behave like BFS-trees and last-in trees that behave like DFS-trees. The search tree paradigms differ from each other by the parent a vertex is connected to. In first-in trees, it is the first visited neighbor, while in last-in trees it is the last neighbor visited before that vertex. Here, we will generalize these concepts of graph search trees by allowing every preceding neighbor of a vertex to be the parent. We study the complexity of the recognition problem of these generalized graph search trees. We present NP-completeness proofs for most searches. We also show that the problem is trivial for Generic Search and polynomial-time solvable for several searches on bipartite graphs and chordal graphs. We also study the question how fixing the start vertex influences the complexity of the problem.

Tue 8 SeptDiscrete MathematicsData Structures and Algorithms
The gist
Graph search trees help computers explore networks or maps by tracking the order in which points are visited. Traditionally, there were two common ways to build these trees, either by connecting a point to the first neighbor visited or to the last neighbor visited before it. This paper studies a wider range where any previous neighbor can be the parent, making the problem more flexible but also harder to solve. The authors find that for most types of searches, figuring out if a tree matches this pattern is very difficult (NP-complete), but easier for certain special graph types and specific searches. They also check whether knowing the starting point simplifies the problem.
Open → 2609.08625v1

Strategy model selection improves stability in multi-agent games

Rank Without an Oracle: Deviation-Aware Interaction-Rank Selection from Offline Multi-Agent Logs

Abstract: Offline multi-agent payoff models are estimated under a logging distribution but used on distributions induced by learned solutions and unilateral deviations. Standard held-out loss can therefore favor an interaction class that predicts logged play well while distorting strategic incentives. We introduce Selective Interaction-Rank Validation (SIRV) for finite games with known logging distributions. A training split fits nested payoff models and constructs a common union of all candidate deployment and unilateral-replacement distributions; an independent calibration split evaluates every candidate on this same union. SIRV returns the smallest rank whose simultaneous upper worst-target risk is within tolerance of the best upper score, and abstains when a declared target is unsupported or too imprecisely estimated. A common coverage event yields a finite-candidate target-risk bound and a candidate-specific coarse correlated equilibrium (CCE) gap certificate. We also isolate an exact two-point off-support non-identifiability result. In a controlled factorial study with 2,048 independent games per family, empirical-Bernstein bounds reduce the median CCE-gap certificate by 42.5% relative to Hoeffding bounds on common returns, with a 1.36-point reduction in supported return. Under paired rank misspecification and in a separately generated congestion family, the SIRV-EB fallback rule lowers mean true candidate-selection CCE regret relative to ID-Mean, while retaining game-level losses. Across 384 games at $N=3,5,8$, ID-Mean-relative mean CCE-regret effects stay positive while certified return falls sharply under weak coverage. These results separate certifiable model selection from universal strategic improvement.

Tue 8 SeptMultiagent SystemsComputer Science and Game Theory
The gist
Predicting how multiple decision-makers interact often uses data from past play, but this can mislead if the situation changes. The authors offer a method called SIRV that better chooses models by checking how well they predict outcomes including possible player changes. This approach helps find models that keep strategic incentives accurate and avoids selecting models that only fit past data well. The method provides guarantees about prediction quality and identifies when data is insufficient, tested on thousands of simulated games.
Open → 2609.08358v1

Deciding directed clique number in tournaments is np complete

Clique Number of Tournaments II

Abstract: The directed clique number $\vecω(T)$ of a tournament $T$ is the minimum, over all orderings of the vertices of $T$, of the clique number of the graph whose edges are the arcs that point backward with respect to the ordering. In this paper, we prove that, for every integer $k \geq 3$, deciding whether $\vecω(T) \leq k$ is NP-complete. This answers a question of Nguyen, Scott, and Seymour, and contrasts with the classical undirected setting, where deciding whether $ω(G) \leq k$ is polynomial-time solvable for every fixed integer $k$. On the other hand, we give a polynomial-time algorithm distinguishing tournaments with $\vecω(T) \leq 2$ from those with $\vecω(T) > 100$. We also study the tournament analogue of the Gyárfás--Sumner conjecture. We construct new $\vecχ$-bounding tournaments and thereby prove a conjecture of Aboulker, Aubian, Charbit, and Lopes stating that every class of tournaments with bounded twin-width is $\vecχ$-bounded. We then exhibit new tournaments that are not $\vecχ$-bounding, disproving another conjecture of Aboulker, Aubian, Charbit, and Lopes, as well as two conjectures of Kim. Finally, we present infinite families of 3-$\vecω$-critical and 4-$\vecω$-critical tournaments.

Mon 7 SeptDiscrete Mathematics
The gist
This paper studies a special math problem involving tournaments, which are games where every player competes against every other player. The authors show that figuring out a certain complexity measure called the directed clique number (a way to find tightly connected groups in these competitions) is very hard to compute—it belongs to a class of problems called NP-complete. However, they also provide an efficient method to distinguish simpler cases from very complex ones. Additionally, the authors explore related properties of tournaments, confirming some previous ideas and disproving others, deepening our understanding of these mathematical structures.
Open → 2609.07481v1

Computing approximate Nash equilibria is nearly optimally slow

The Fine-Grained Complexity of Approximate Nash Equilibrium and Free Games

Abstract: We study the fine-grained complexity of computing approximate Nash equilibria and approximating the value of free games in the regime where the approximation error vanishes. Under the PCP for PPAD and ETH for PPAD conjectures, we show that computing $\varepsilon$-approximate Nash equilibria in 2-player $N$-action normal-form games requires time $N^{(\log(N)/\varepsilon^2)^{1-o(1)}}$, thus showing that the classical Lipton-Markakis-Mehta algorithm (2003) is optimal through all regimes of $\varepsilon = ω(1/\sqrt{N})$. While such optimality was known in the constant-$\varepsilon$ regime (Rubinstein, 2016), previous work could only rule out significantly smaller running times of $N^{O(\log(N)/\varepsilon)}$ in the regime $\varepsilon = o(1)$. Using similar techniques, we then establish an analogous tight lower bound of $N^{(\log(N)/\varepsilon^2)^{1-o(1)}}$ under ETH for $\varepsilon$-additive value estimation in free games, when $\varepsilon \geq 2^{-o(\sqrt{\log N})}$, answering a question of Aaronson, Impagliazzo, and Moshkovitz (2014).

Mon 7 SeptComputer Science and Game TheoryComputational Complexity
The gist
Finding approximate Nash equilibria, a way for players to predict stable strategies in games, is very hard when the approximation needs to be very precise. The authors show that existing algorithms are essentially the fastest possible for a wide range of precisions. They also prove a similar hardness for estimating values in special two-player games called free games. This means that speeding up calculations in these areas is likely impossible without major breakthroughs.
Open → 2609.07136v1