Papers for

network 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.

Improved clustering algorithms with limited extra centers and strict capacities

Uniform Capacitated Clustering with Few Extra Centers

Abstract: In uniform capacitated $(k,z)$-clustering, we open $k$ centers and assign every client to a center so that no center serves more than $U$ clients, minimizing the sum of the $z$-th powers of the assignment distances; $k$-median and $k$-means are the cases $z=1$ and $z=2$. We study algorithms that may open $k+\lfloor\varepsilon k\rfloor$ centers for a fixed $\varepsilon\in(0,1]$ and must respect the capacities exactly. In low dimensions, we give deterministic algorithms that are, except for $k$-median in the plane, the first polynomial-time algorithms with $(1+\varepsilon)k$ centers whose ratio is bounded independently of $\varepsilon$. In Euclidean space of any dimension, with clients of bounded doubling dimension, the ratio is $\mathcal{B}_z-(\mathcal{B}_z-1)\varepsilon+δ$ for every fixed $δ>0$, where $\mathcal{B}_z<3^z$ for $z>1$; this is $3-2\varepsilon+δ$ for $k$-median and $5-4\varepsilon+δ$ for $k$-means. In doubling metrics, the ratio is $3^z-(3^z-1)\varepsilon+δ$ when centers may share a location, and a constant otherwise, such as $\min\{7-4\varepsilon,\,3+2\ln(1/\varepsilon)\}+δ$ for $k$-median. In general metrics, deleting centers greedily gives ratio $3+2\ln(1/\varepsilon)+δ$ for $k$-median when centers may share a location and $7+2\ln(1/\varepsilon)+δ$ otherwise, improving the previous $O(\varepsilon^{-2}\log(1/\varepsilon))$. Our main tool is a rescue lemma. Splitting a near-optimal uncapacitated solution gives at most $2k-1$ blocks of at most $U$ clients, and giving a block a private center saves its share of the extra cost of following an optimal solution. Since a center of the optimal solution can be closed once all its blocks are rescued, $\lfloor\varepsilon k\rfloor$ extra centers save almost an $\varepsilon$-fraction of this extra cost instead of an $\varepsilon/2$-fraction.

Thu 29 OctComputational GeometryData Structures and Algorithms
The gist
The paper deals with a common problem in organizing clients by assigning them to facilities without exceeding the maximum capacity per facility. The authors develop new algorithms that allow opening slightly more than the original number of centers, while ensuring no center is overloaded and the overall client-to-center distance is kept low. These algorithms work well in various metric spaces, including Euclidean spaces and others with a notion of doubling dimension. Their main technical advance is a smart way to handle extra centers to reduce the cost of assigning clients, improving previous guarantees.
Open → 2610.40625v1

Approximation methods improve building binary trees from general trees

From Trees to Binary Trees: Approximation Algorithms and a PTAS

Abstract: Kellerhals, Krebs, Nichterlein, and Schmid introduced the optimization problem Tree in Binary Tree (TBT), where, given a tree $T$, the task is to find a binary tree $S^*$ with $V(T)=V(S^*)$ that minimizes $\sum_{uv\in E(T)} \operatorname{dist}_{S^*}(u,v)$. They also introduced the variant Tree in Binary Tree With Steiner Nodes (TBT-SN), where the condition $V(T)=V(S^*)$ is relaxed to $V(T)\subseteq V(S^*)$. We give a simple linear-time $\frac{8}{3}$-approximation algorithm for TBT and a polynomial-time approximation scheme (PTAS) for TBT-SN. Our main building idea in both algorithms is to iteratively consider subtrees of the tree $T$ which contain all vertices below some vertex $v$ and construct a solution where $v$ has degree 1. For the PTAS, we cut $T$ into smaller trees, solve these instances, modify the obtained solutions, and combine them to achieve a solution for the original instance.

Thu 29 OctData Structures and Algorithms
The gist
The paper addresses how to convert a given tree structure into a binary tree that keeps the same nodes but arranges them so distances between connected nodes stay as short as possible. The authors improve previous work by providing a straightforward algorithm that quickly finds a solution within about 2.67 times the optimal distance sum. They also present a more complex method that can get arbitrarily close to the best possible solution when extra nodes (Steiner nodes) are allowed. Their approach breaks down the tree into parts, solves each, and then combines these solutions.
Open → 2610.39863v1

Diameter two graphs discovered with equal coloring and visibility numbers

Diameter-two graphs whose mutual-visibility chromatic number equals their chromatic number

Abstract: A set $S$ of vertices of a graph $G$ is a mutual-visibility set if every pair of vertices of $S$ is joined by a shortest path whose internal vertices avoid $S$, and the mutual-visibility chromatic number $χ_μ(G)$ is the least number of mutual-visibility sets into which $V(G)$ can be partitioned. Klavžar, Kuziak, Valenzuela Tripodoro and Yero (2025) proved that $χ_μ(G)\leχ(G)$ whenever $G$ has diameter two, observed that equality holds for complete bipartite graphs, and asked whether there are any other diameter-two graphs attaining equality. We answer this question in the affirmative. We construct a graph $G_{11}$ of order 11 and diameter two with $χ_μ(G_{11})=χ(G_{11})=3$, and an infinite family of such graphs obtained from $G_{11}$ by replacing one vertex with pairwise non-adjacent copies of it.

Thu 29 OctDiscrete Mathematics
The gist
This paper looks at a special way of coloring points in a network so that each color group has a visibility property. Earlier work showed that for networks where any two points are close, the minimum number of color groups needed with this visibility matches or is less than normal coloring. The authors found new examples of such networks where these two numbers are exactly equal and created an infinite family from these examples. This helps better understand how visibility and coloring relate in small-diameter networks.
Open → 2610.39430v1

Efficient generation of spanning arborescences with minimal edge changes

Generating pivot Gray codes for spanning arborescences of complete digraphs and split digraphs in constant amortized time

Abstract: We present the first known efficient algorithm to generate pivot Gray codes for spanning arborescences of complete digraphs, listing all spanning arborescences such that consecutive arborescences differ by reassigning the outgoing edge of exactly one vertex. Our recursive algorithm generates each spanning arborescence in constant amortized time using $O(n^2)$ space. We then extend our algorithm to generate the first known pivot Gray codes for spanning arborescences of split digraphs, achieving constant amortized time per arborescence using $ O(n^2) $ space. Finally, we further generalize our approach to proper interval digraphs. When the arborescences are rooted at the leftmost interval, our algorithm generates the pivot Gray code in constant amortized time per arborescence using $ {O}(n^2) $ space.

Tue 27 OctData Structures and Algorithms
The gist
The paper addresses how to list all possible spanning arborescences—special directed trees—in certain types of directed graphs so that moving from one tree to the next requires only changing one edge. The authors develop the first known fast method that does this for complete digraphs, split digraphs, and certain interval digraphs. Their approach uses a clever recursive algorithm that runs quickly and uses reasonable memory. This means it’s possible to explore these structures one by one with minimal changes between them.
Open → 2610.37783v1

Algorithm colors 3-colorable graphs using fewer colors efficiently

An $O(n^{0.1537})$-Coloring Algorithm for 3-Colorable Graphs

Abstract: We present a polynomial-time randomized algorithm that colors every $n$-vertex $3$-colorable graph with $O(n^{0.1537})$ colors. This improves upon the previous bound of $O(n^{0.1954})$ colors by Bansal, Huang, and Lee (SODA '27). To achieve this result, we introduce a new algorithmic framework for finding a large independent set from a solution to the vector coloring SDP. Combined with the (combinatorial) dense-progress algorithm of Kawarabayashi, Thorup, and Yoneda (STOC '24), this framework yields an $n^{1/6 + o(1)}$-coloring algorithm. Furthermore, we strengthen the SDP-based algorithm specifically for 3-colorable graphs to achieve $O(n^{0.1537})$ colors.

Mon 26 OctData Structures and Algorithms
The gist
Coloring a graph means assigning colors to points so connected points have different colors. When a graph can be colored with three colors, finding such a coloring is very hard. The authors created a faster algorithm that uses fewer colors than previous methods on graphs known to be 3-colorable. They improved the mathematics behind the coloring and combined new and existing methods to reduce the number of colors needed, making the coloring process more efficient.
Open → 2610.35859v1

Antimagic labeling proven for certain loop-based central digraphs

Antimagic Labeling of Central Digraphs Constructed from Loops

Abstract: Let $(T, \circ)$ be a loop of order $k \geq 3$ and $D_S^*$ the loopless central digraph obtained from the associated central digraph $D_S$ by removing the $k$ self-loops at the diagonal vertices. We construct an explicit arc-labeling $f$ of $D_S^*$ ordering all arcs lexicographically by $(\text{tail}, \text{head})$ and assigning labels $1, \ldots, m$ in that order and prove that $f$ is an antimagic labeling. Consequently, $D_S$ is antimagic for every loop of order $k \geq 3$, a property that depends only on $k$ and is invariant across all non-isomorphic loops of the same order.

Mon 26 OctDiscrete Mathematics
The gist
The paper studies a special way to assign numbers to the connections (arcs) between points (vertices) in a certain type of directed graph made from mathematical loops. They show explicitly how to label these arcs so that each point gets a unique sum of incoming and outgoing arc labels, which is called an antimagic labeling. This property holds for all such graphs created from loops with at least three elements, regardless of the specific structure of the loop. Essentially, they provide a new proof that all these graphs have this unique numbering property.
Open → 2610.35419v1

No lattice tilings by Lee balls in three or more dimensions

The Golomb--Welch conjecture for lattice tilings

Abstract: We prove the Golomb--Welch conjecture for lattice tilings: for every $n\ge3$ and $r\ge2$, the integer lattice $\Z^n$ admits no lattice tiling by Lee balls $B_n(r)$ of radius $r$. Together with the classical constructions for $n\le2$ and for $r=1$, this determines all parameters for which a lattice Lee tiling exists. Equivalently, we show that every abelian Cayley graph of even degree $2n\ge6$ and diameter $r\ge2$ has strictly fewer than $|B_n(r)|$ vertices.

Sun 25 OctInformation Theory
The gist
This paper shows that when you try to cover an infinite grid in three or more dimensions using copies of a certain shape called a Lee ball, you can’t do it perfectly with a repeating pattern if the ball’s radius is bigger than one. The authors proved this was impossible for all such cases, completing the understanding of when perfect lattice coverings by these shapes exist. This also tells us something about certain kinds of networks formed from mathematical groups, limiting how large these networks can get when they have given properties.
Open → 2610.33983v1

Polynomial-time alternating paths and 2-colour partitioning hardness

Acyclic 2-edge-coloured graphs: polynomial-time linkages and colouring hardness

Abstract: A path or cycle in a $2$-edge-coloured graph is alternating if consecutive edges have different colours. These objects are natural analogues of paths and cycles in graphs, and even more so in digraphs. A well-studied class is that of acyclic $2$-edge-coloured graphs, that is, those forbidding alternating cycles. In particular, (acyclic) $2$-edge-coloured graphs generalize directed (acyclic) graphs (DAGs), but the complexity of problems on DAGs is much better understood than that of the corresponding problems on acyclic $2$-edge-coloured graphs. We investigate the complexity of two such problems, whose directed counterparts are well-known. Our first result is an $n^{O(k)}$-time algorithm for the alternating $k$-linkage problem on acyclic $2$-edge-coloured graphs. This problem asks for $k$ vertex-disjoint alternating paths joining $k$ prescribed pairs of vertices. This generalizes the directed $k$-linkage algorithm for DAGs. For every fixed $k$, this also yields a polynomial-time algorithm for finding $k$ internally vertex-disjoint alternating $(s,t)$-paths, solving an open problem by Abouelaoualim et al. from 2008. We then consider the alternating chromatic number of $2$-edge-coloured graphs, defined as the minimum number of parts in a vertex partition such that each part induces an acyclic subgraph. This notion is analogous to the dichromatic number of digraphs, where it is known that deciding dichromatic number $2$ is NP-complete even on tournaments. Our second result is that deciding alternating chromatic number $2$ is NP-complete on complete $2$-edge-coloured graphs. Equivalently, deciding whether a graph can be partitioned into two induced threshold graphs is NP-complete.

Fri 23 OctData Structures and Algorithms
The gist
The paper studies special paths in graphs where edges can be one of two colours and paths must alternate colours along the way. The authors find a method to efficiently find multiple disjoint alternating paths in such graphs, solving a long-standing problem. They also show that figuring out if a graph can be split into two parts without alternating cycles is computationally very hard. This generalizes known results from simpler directed graphs to more complex coloured versions.
Open → 2610.32954v1

Matroid base optimization enables faster group label constraint solutions

Proximity Theorem and FPT Algorithm for Minimum Group-labeled Matroid Bases

Abstract: Let $M$ be a matroid, let $\ell:E(M)\to G$ be a labeling of its elements by an abelian group, and let $F\subseteq G$ be finite. A base is $F$-avoiding if the label sum of its elements is not in $F$. We prove that, for arbitrary costs, a min-cost $F$-avoiding base can be obtained from any min-cost base using at most $|F|$ exchanges. This resolves the weighted proximity conjecture by Hörsch, Imolay, Mizutani, Oki, and Schwarcz. Our main technical tool is to replace the assumption of Schrijver--Seymour Conjecture in Liu and Xu's earlier work with Kemperman--Scherk Theorem. The proximity theorem combined with approaches in earlier work gives an FPT algorithm that finds a min-cost $F$-avoiding base parameterized by $|G|$. We additionally give an FPT algorithm parameterized by $|F|$, answering a question of Hörsch et al.

Fri 23 OctData Structures and Algorithms
The gist
Matroids are mathematical objects that describe structures with a notion of independence, like networks or graphs. This paper looks at ways to find the least costly group of elements (a "base") whose combined labels, from a group, avoid certain forbidden sums. The authors prove that only a limited number of swaps are needed to move from any cheapest base to one that avoids these sums and provide algorithms that quickly find such solutions when the size of the group or forbidden sets is small. This advances understanding and tools for optimizing with complex group-label constraints.
Open → 2610.32798v1

Graphs covered by few shortest paths have bounded pathwidth

Polynomial pathwidth for graphs vertex-coverable by few shortest paths and algorithms for quasi-shortest path covers

Abstract: We study how covering a graph by a small number of shortest or approximately shortest paths/walks constrains its treewidth and pathwidth. A path or walk is $(α,β)$-quasi-shortest for $α\geq1$ and $β\geq 0$ if each contiguous segment has length at most $α$ times the distance between its endpoints plus $β$. For graphs vertex-covered by $k$ shortest paths, we establish the first known polynomial pathwidth bound of $O(k^3)$. For edge-coverage, we improve the previously known $O(k^4)$ upper bound to $O(k^2\log k)$. As a main ingredient of the proofs, we first show that if the vertices of a graph can be covered by $k$ $(α,β)$-quasi-shortest paths or walks, then its treewidth is $O_{α,β}(k^2)$; this is a consequence of the fact that such graphs have linear metric growth and the technique developed in [Campbell et al., E-JC 2023]. To obtain the above pathwidth upper bounds, we combine this result with techniques from the literature in a nontrivial way. On the other hand, we show that there exist connected bipartite cubic graph whose edges can be covered by $k$ shortest paths and whose pathwidth is $Ω(k\log k)$, providing the first superlinear lower bound. For graphs covered by $k=2$ $(α,0)$-quasi-shortest paths with $α>1$, we show that, unlike treewidth and unlike the case $α=1$ and $β=0$ of exact shortest paths, the pathwidth may be unbounded. Finally, for every fixed rationals $α\geq1$ and $β\geq 0$, we give XP algorithms with a running time of $n^{f(k,α,β)}$ for some function~$f$ that decide whether the vertices of a graph can be covered by at most $k$ $(α,β)$-quasi-shortest paths or walks. The algorithms combine our treewidth upper bounds with an algorithmic meta-theorem from [Dreier et al., LICS 2025]. [abstract shortened to meet the arXiv requirements]

Wed 21 OctDiscrete MathematicsData Structures and Algorithms
The gist
This paper looks at how having just a few shortest paths can cover a graph limits how complicated it can be, measured by pathwidth and treewidth. The authors found a way to show that if a few shortest or nearly shortest paths cover all the points of a graph, the complexity grows only polynomially with the number of paths. They also found better and new bounds for cases where edges, instead of points, are covered by paths. Additionally, they present algorithms to decide if such coverings exist, although some examples show that complexity can still get quite large in certain tricky cases.
Open → 2610.30458v1

Algorithms for partitioning weighted trees without conflicting terminals

Algorithms for Connected Multicuts of Weighted Trees

Abstract: In the \emph{connected multicut problem for weighted trees}, the instance is an edge-weighted tree $T = (V,E,ω)$, a set of terminals $Γ\subseteq V$, and a set of pairwise ``conflicts'' between these terminals represented by edges of a conflict graph $\mathcal{C} = (Γ,\mathcal{F})$. A \emph{connected multicut} for this instance is a partition $\mathcal{M}$ of the vertex set $V$ into subsets called the \emph{components of $\mathcal{M}$}, where each component induces a subtree of $T$, contains at least one terminal, but does not contain any conflicting terminal pair. Two cost functions for multicuts are considered: in the min-sum variant, we minimize the total weight of the edges between different components of $\mathcal{M}$, and in the min-max variant, we minimize the maximum, over all components, of the total weight of edges leaving the component. In the first part of the paper, we focus on algorithms for the min-max variant, for which we give a $2$-approximation algorithm for the unweighted case, a $(2+ε)$-approximation algorithm for the general case, and a mildly exponential exact algorithm for the unweighted case. In the second part of the paper, we study algorithms that take advantage of the structure of the conflict graph. We first give a polynomial-time exact algorithm for the min-max variant when $\mathcal{C}$ is a clique (the variant referred to in the literature as the \emph{multiway cut}). Next, we generalize this result by providing polynomial-time exact algorithms, for both variants, for instances whose conflict graph has constant \emph{split complexity} --- a new parameter that refines the concept of neighborhood diversity previously studied in the context of parameterized complexity. This unifies and generalizes previous results for the min-sum variant when conflict graphs are complete multipartite graphs or unions of cliques.

Sat 17 OctData Structures and Algorithms
The gist
This research looks at ways to cut up a weighted tree structure into connected parts, each containing certain important points called terminals, while avoiding pairs of points that conflict with each other. The goal is to split the tree so that the cost of cutting edges is minimized in two different ways. The authors provide approximate and exact algorithms for these problems, especially when the conflict patterns among terminals have specific structures. They also introduce a new way to measure conflict complexity, broadening previous methods.
Open → 2610.24886v1

Strong total cover problem links graph sets and matching complexity

The Strong Total Cover Problem

Abstract: The Strong Total Cover Problem (STCP) is a novel covering problem defined on a graph $G = (V, E)$, where the objective is to find a minimum-cardinality subset $T \subseteq V \cup E$ such that every element of $V \cup E$ is covered. In this setting, a vertex covers itself and all its incident edges, while an edge covers itself together with its two endpoints. The STCP resembles classical covering problems such as Vertex Cover and Edge Cover problems, and naturally arises as the dual of the total matching problem. In this paper, we investigate the STCP from algorithmic, complexity, and polyhedral perspectives. We first establish close connections between STCP, the Dominating Set Problem, and the Maximum Induced Matching Problem. These relationships provide structural insights, imply the NP-hardness of STCP, and identify graph classes for which the problem is polynomial-time solvable. We then investigate the weighted version of STCP, showing that it remains NP-hard even on complete graphs with binary weights. On the other hand, we present a 2-approximation algorithm, and a polynomial-time algorithm for complete bipartite graphs. On the polyhedral side, we introduce the Strong Total Cover Polytope and derive several families of valid inequalities, some of which are shown to define facets. Finally, we provide a complete linear description of the associated polytope for triangular cactus graphs, revealing an interesting contrast with the considerably more intricate facial structure of the dominating set polytope on cactus graphs.

Fri 16 OctDiscrete MathematicsComputational Complexity
The gist
The paper studies a new problem on graphs where one must pick the smallest set of nodes or edges to cover everything in the graph. Vertices cover themselves and their edges, while edges cover themselves and their endpoints. The authors show this problem is difficult to solve in general, similar to some well-known problems, but find some simpler cases where it can be solved efficiently. They also develop approximation methods and characterize geometric structures related to the problem, providing insights that could help design better algorithms.
Open → 2610.23312v1

Tree labeling inequality fails for caterpillars with many internal vertices

Counterexamples to the local antimagic leaf conjecture

Abstract: It has been conjectured that $χ_{\mathrm{la}}(T)\leq\ell(T)+2$ for every tree $T$ of order at least three, where $χ_{\mathrm{la}}(T)$ is the local antimagic chromatic number and $\ell(T)$ denotes the number of leaves. We disprove this bound and show that no absolute constant can replace $2$ in an inequality of this form. Our approach uses degree-based intervals containing all possible induced vertex weights under bijective edge labelings, together with a separation criterion that forces selected internal vertex weights to be distinct. We first construct caterpillars $T_3$ and $T_4$ satisfying $χ_{\mathrm{la}}(T_3)=\ell(T_3)+3$ and $χ_{\mathrm{la}}(T_4)=\ell(T_4)+4$, respectively. We then construct, for every positive integer $r$, infinitely many pairwise nonisomorphic caterpillars with exactly $r$ internal vertices for which every bijective edge labeling is antimagic. Each such caterpillar $T$ satisfies $χ_{\mathrm{la}}(T)=|V(T)|=\ell(T)+r$. Consequently, $χ_{\mathrm{la}}(T)-\ell(T)$ is unbounded even within the class of caterpillars, and no absolute constant $C$ can satisfy $χ_{\mathrm{la}}(T)\leq\ell(T)+C$ for every tree $T$.

Fri 16 OctDiscrete Mathematics
The gist
This paper studies a math puzzle about labeling the connections (edges) in tree-shaped graphs so that the sums at each point (vertex) create a special color pattern. Previously, it was guessed that the number of colors needed relates closely to the number of endpoints (leaves) in the tree plus a small fixed number. The authors found examples where this number is much bigger, showing the guess is false even for simple tree structures called caterpillars. They also prove that no fixed number can replace the small fixed number in every case.
Open → 2610.22783v1

Graphs excluding fixed minors have limited large scale complexity

Asymptotic dimension of graphs excluding an induced or fat minor

Abstract: Asymptotic dimension is a large-scale invariant of metric spaces that was introduced by Gromov (1993). A major open problem in coarse graph theory asks whether, for every fixed graph $H$, the class of graphs excluding $H$ as a fat minor has bounded asymptotic dimension. A weaker conjecture asserts the same conclusion for graphs excluding $H$ as an induced minor. We substantially expand the range of graphs $H$ for which these conjectures are known to hold. Specifically, we prove bounded asymptotic dimension for the following classes of graphs: graphs excluding a fixed planar graph as a fat minor; and graphs excluding a fixed string graph as an induced minor. All of our results also hold for the stronger notion of Assouad--Nagata dimension, a refinement of asymptotic dimension. These results have a number of applications, two of which we mention here. First they imply that an induced minor-closed class is $χ$-bounded if and only if it does not contain some Burling graph. Second they imply that, in graph classes excluding a fixed planar graph as an induced minor, treewidth is polynomial in maximum degree.

Thu 15 OctDiscrete Mathematics
The gist
This paper studies a way to measure how complicated large networks are when they don't contain certain smaller networks inside them. The authors focus on two types of forbidden smaller networks called fat minors and induced minors. They show that graphs excluding certain planar or string-shaped subgraphs have a bounded measure called asymptotic dimension, which limits their complexity at a large scale. This also relates to practical properties like restricting how connected parts of a graph get as they grow larger.
Open → 2610.22495v1

Improved method achieves better than two approximation for k median problem

A Better-than-2 Approximation for k-Median Part I: The Power of General Bids

Abstract: The Greedy algorithm of Jain, Mahdian, Markakis, Saberi, and Vazirani was the best Lagrangian-multiplier-preserving (LMP) approximation algorithm for facility location, and thus the engine behind the best $k$-median guarantees, for over two decades. Its $2$-LMP guarantee was only recently broken by a small amount ($(2-η)$-LMP where $η\approx 2.25 \cdot 10^{-7}$) through local-search post-processing. That analysis relies on the structure of worst-case instances, and it appears difficult to obtain substantial further improvements along those lines. We take a different approach and change the algorithm itself: we introduce general bidding functions, replacing the classical linear bid with a richer family of rules and prove a polynomial-time $1.95$-LMP approximation, a large improvement over the long-standing factor of~$2$. We further show that these generalized bidding rules can be made smooth (log-adaptive), building on the recent framework developed for the classical Greedy algorithm by Cohen-Addad, Grandoni, Lee, Schwiegelshohn, and Svensson. This yields a polynomial-time $1.95$-approximation that opens $k+O_\varepsilon(\log n)$ centers. Combined with a $(1.89+\varepsilon)$-approximation algorithm for stable instances in our companion work \cite{stableinstances}, we achieve a better-than-2 approximation for the $k$-median problem in polynomial-time.

Tue 13 OctData Structures and Algorithms
The gist
The k-median problem involves choosing locations to serve many clients with minimum total distance. For over 20 years, a certain Greedy algorithm gave a roughly twice-as-good-as-optimal solution. The authors changed the way bids are calculated in the algorithm, using more flexible rules, which led to a notable improvement with a 1.95 approximation factor. Their approach also adapts smoothly to input size and complexity, opening slightly more locations but achieving better overall results. Together with other work, they provide the first polynomial-time method beating the factor of two for k-median.
Open → 2610.18144v1

Routing optimality holds for networks with simple demand connections

Routing Optimality for Demand Graphs of Matching Number at Most Two

Abstract: We prove that network coding and fractional routing have the same capacity region in undirected networks whose demand graph has matching number at most two, that is, when no three demand edges have pairwise disjoint endpoints. The metric-packing reduction of Liu et al. reduces this problem to a distance-weighted communication inequality on the fixed graph $Γ_{3,3}$. We first prove two entropy inequalities for sessions between designated terminal pairs on $Γ_{3,3}$. We then extend this result to sessions with arbitrary endpoints to obtain the distance-weighted communication bound required by the reduction. The proof combines conditional entropy inequalities with two graph contractions and an information inequality for deterministic interaction. Combining this inequality with the existing reduction establishes routing optimality for this class of demand graphs.

Tue 13 OctInformation Theory
The gist
The paper explores how data can be efficiently sent over networks when the demands have a simple structure, specifically when there are no three completely independent demand pairs. The authors show that routing data in these cases can be just as good as more complex methods that mix or code information. They prove this by studying special graphs and using mathematical inequalities related to information theory. This result confirms that in such networks, straightforward routing is optimal and no complicated coding tricks improve capacity.
Open → 2610.17911v1

Simultaneous planar drawing problem solved with vertex integrity parameter

Ramsey Meets Simultaneous Planarity: Vertex Integrity and Pathwidth

Abstract: We study the following simultaneous embedding problem: Given k graphs on the same vertex set with the same pairwise intersection, do they admit planar drawings that coincide on their shared graph? We establish fixed-parameter tractability with respect to the vertex integrity of the union graph (that is, the union of the input graphs) plus k, resolving an open question and generalizing the known algorithm parameterized by vertex cover number plus k. Our main technical contribution on the way towards this result is the extension of the recently introduced Ramsey pruning technique beyond ordering problems. Finally, we complement our tractability result with a lower bound that establishes NP-hardness when both k and the pathwidth of the union graph are bounded by constants, ruling out a generalization of our main result to path- or treewidth.

Mon 12 OctData Structures and Algorithms
The gist
This paper studies how to draw multiple graphs that share some connections on the same set of points without their lines crossing. The authors developed a method that can efficiently determine if such drawings are possible by focusing on a property called vertex integrity, which relates to how the graphs are connected overall. They also show that using a different graph complexity measure, called pathwidth, does not help, as the problem remains hard even when pathwidth is small. A new technique called Ramsey pruning was extended to help with this problem.
Open → 2610.16392v1

Simplified proof improves key math problems with faster algorithms

A simplified proof of polynomial improvements for 3SUM and APSP

Abstract: We give a simplified proof of the polynomial improvements for integer 3SUM and all-pairs shortest paths (APSP) established by Alman and Vassilevska Williams, with weaker exponents. The central ingredient is selected-entry matrix multiplication: computing a prescribed set of entries of a product of dense rectangular matrices. Starting from Schönhage's inner/outer-product identity, we construct a multiplication rule that shares intermediate products among many outputs. We apply this rule recursively and bound the work by counting the requested entries at each level. Applied to incidence matrices, the algorithm solves Offline Set Disjointness over a small universe. Known deterministic reductions then yield truly subquadratic integer 3SUM and truly subcubic APSP for polynomially bounded integer inputs.

Sun 11 OctComputational Complexity
The gist
Some important math problems, like finding three numbers that add up to zero or calculating shortest paths in networks, usually take a long time to solve on computers. The authors present a simpler way to show that these problems can be solved faster than we thought, using clever math tricks involving multiplying parts of big tables of numbers. Their approach reduces the time for these problems when inputs are certain kinds of integers, helping algorithms run more quickly.
Open → 2610.15663v1

Improved algorithms for local approximation in network graph problems

Almost Lossless Transfer for Cuttable Distributed Problems

Abstract: We study constant-round LOCAL approximation for additive local vertex-subset minimization problems. Given a $k$-uniform $α$-approximation on a hereditary source class closed under disjoint union, Bonamy, Das, Gavoille, Picavet, Suomela, and Wesolek obtained ratio $α(d+1)+1$ on locally nice target classes of asymptotic dimension $d$. We prove two transfers with ratios $α+1+η$ and $α+η$ for every $η>0$. These bounds require the stronger local niceness assumption at a larger scale that depends on $η$. The first algorithm keeps their repair construction and increases the radius used to detect errors. We average over partitions of the graph to bound the retained cost without the factor $d+1$. These partitions are used only in the analysis. The second algorithm tests several deletion widths around the errors. In each component of the repair zone, it chooses a smallest union of retained choices and an exact repair. Averaging over the widths bounds the cost counted twice and yields ratio $α+η$. Both transfers are deterministic and computable, use arbitrary distinct numerical identifiers, and need no knowledge of the graph size. Their outputs also satisfy local uniformity guarantees. For 2-domination on graphs of bounded Euler genus, the same planar source gives ratio $19$ through the earlier transfer and $6+η$ through ours. For minimum dominating set, our transfer gives ratio $7+\varepsilon$ on graphs formed by attaching a clique of arbitrary size at one vertex of a planar graph, using the source algorithm of Amiri and Siebertz. This class satisfies our target assumptions and allows nonempty error sets. Its Euler genus is unbounded, so their guarantee for graphs of bounded Euler genus does not cover the whole class.

Sun 11 OctData Structures and AlgorithmsDistributed, Parallel, and Cluster Computing
The gist
The paper studies how to find near-optimal small sets of points in networks using only local information, with very limited rounds of communication. The authors improve previous methods by reducing extra costs in approximations for certain complex network classes. Their new algorithms carefully detect and fix errors better and use clever averaging techniques to get closer to the best solutions. They show that these methods offer stronger guarantees for network graphs, including some that were not covered before.
Open → 2610.15596v1

New graph class links labeling to unweighted caterpillar tree structures

Pairwise Compatibility Graphs of Unweighted Caterpillars

Abstract: In this paper we study pairwise compatibility graphs whose witness tree is required to be an unweighted caterpillar. This is a natural restriction of PCGs, in the same line of research as the study of star witnesses, which led to the class of double-threshold graphs. In the caterpillar case, we show that this restriction is equivalent to a one-dimensional difference-labelling problem: a graph admits such a representation if and only if its vertices can be assigned integer labels so that adjacency is determined exactly by whether the absolute difference of two labels belongs to a given interval. Using this characterization, we derive structural properties of the class, including bounded twin-width, and study its relation with familiar graph families. We show that the class contains cycles and two-dimensional grids, while it excludes natural obstructions such as the subdivided star $S_{2,2,2,2,2}$, the cube graph $Q_3$, the wheel $W_6$, and the complement of the $3$-sunlet. We also consider restricted representations, including centipede witnesses and representations with a given interval and we give a polynomial-time recognition algorithm when the interval is fixed.

Sat 10 OctDiscrete Mathematics
The gist
Some graphs can be represented by linking their points using a special kind of tree called a caterpillar, where edges connected in a simple way matter. The authors show that understanding such graphs is the same as assigning numbers to nodes so that two nodes connect if their number difference lies in a certain range. This insight reveals properties of these graphs and how they relate to familiar shapes like cycles and grids but exclude others like certain stars or cubes. They also provide a way to decide if a graph can be represented this way quickly when the number range is fixed.
Open → 2610.14681v1

Directed treewidth polynomially ensures large low-congestion brambles

Polynomial directed treewidth forces a large bramble with congestion two

Abstract: Brambles of constant congestion in directed graphs have interesting structural and algorithmic applications, and it is desirable to find the smallest function $f_c(k)$ such that if a digraph has directed treewidth at least $f_c(k)$, then it contains a bramble of size at least $k$ and congestion at most $c$. By the Directed Grid Theorem of Kawarabayashi and Kreutzer [STOC 2015], such a function $f_c(k)$ exists for every value $c \geq 2$ of the congestion. However, even using the recent improvements due to Hatzel et al. [FOCS 2024], the resulting function is a power tower of height $22$. Recently, Masařík et al. [SIAM J. Discrete Math. 2022] proved that, for congestion $8$, the function $f_8(k)$ can be made polynomial; more precisely, they showed that $f_8(k) = \mathcal{O}(k^{48} \cdot \log^{13} k)$. They asked whether it is possible to decrease the congestion, ideally to $2$, even at the cost of a higher polynomial function. In this work we answer their question affirmatively with the best possible value of the congestion, by proving that $f_2(k) = \mathcal{O}(k^{96}\cdot \log^{23} k)$. We also obtain smaller polynomials for higher congestion, namely $f_4(k) = \mathcal{O}(k^{72} \cdot \log^{21} k)$ and $f_6(k) = \mathcal{O}(k^{66} \cdot \log^{18} k)$. Our results are inspired by the proof for congestion $8$, which we improve by introducing walkages. Walkages allow us to avoid technicalities of the original proof by translating ideas due to Reed and Wood [Eur. J. Comb. 2012] that work for undirected graphs to the directed setting. Our proofs are constructive and naturally yield polynomial-time algorithms to find the brambles assuming a certificate for large directed treewidth is given. Moreover, we discuss algorithmic applications of our results for the Directed Disjoint Paths with Congestion problem, and to half-integral packings of subgraphs with large directed treewidth.

Fri 9 OctData Structures and AlgorithmsDiscrete Mathematics
The gist
Directed graphs can be complex, and one way to study their structure is through something called directed treewidth. Larger directed treewidth often means the graph contains complicated patterns called brambles. The authors show that if the directed treewidth is big enough—following a polynomial formula—then the graph must have a large bramble with low congestion, specifically congestion two, which is simpler than previously known results. This advances understanding of how graph complexity relates to these patterns and provides algorithms to find them efficiently, improving prior methods.
Open → 2610.13270v1

Chordal graphs linked to new coloring conditions for spanning trees

On Hypergraph Colorings and Completely Independent Spanning Trees in Chordal Graphs

Abstract: In this paper, we study the existence problem of completely independent spanning trees (CIST) in chordal graphs through appropriate hypergraph representations and their panchromatic and bipanchromatic colorings. First, we disprove a conjecture stating an exact relationship between the panchromatic number, the bipanchromatic number, and the minimum number of unique colors in an optimal panchromatic coloring of a hypergraph. Then, by relating CIST to panchromatic and bipanchromatic colorings of the associated hypergraphs, we derive structural conditions for their existence in chordal graphs and specifically strictly chordal graphs.

Tue 6 OctDiscrete Mathematics
The gist
The paper looks at how a special kind of network, called chordal graphs, can be better understood using color-coded groups called hypergraphs. The authors show that a previously believed exact relationship about colors doesn’t always hold. They also find new rules that help check when special kinds of spanning trees, called completely independent spanning trees, exist in these networks. This could help understand complex connections more clearly.
Open → 2610.08042v1

Socially best groupings can be unstable to coalitions in graph games

Social Optimality Does Not Imply Coalitional Stability in Unweighted Max-k-Cut Games

Abstract: In Max-$k$-Cut games, optimal colorings maximize social welfare, but are they stable against coordinated deviations that strictly benefit every participating player? A recurring conjecture in the literature asserts that, for unweighted graphs, every optimal coloring has this stability property, known as strong equilibrium. We disprove the conjecture for every $k\ge3$ by exhibiting a finite, simple, connected, unweighted graph with an optimal coloring that is not a strong equilibrium. The profitable coalitional deviation leads to another optimal coloring: every coalition member gains, while players outside the coalition bear the corresponding losses and social welfare remains unchanged. We also give an exact identity relating coalitional gains, changes in cut value, and internal conflicts, recovering the known stability guarantee for optimal colorings when the maximum degree is at most $2k-1$. For strong deviations from general Nash equilibria, we establish a sharp upper bound on the number of monochromatic edges remaining within the coalition and show that this number can exceed the coalition size.

Sun 4 OctComputer Science and Game Theory
The gist
Max-k-Cut games involve coloring nodes in a network to maximize connections between different colors, which is good for everyone overall. It was believed that these best possible colorings are stable, meaning no group of players can switch colors together to all benefit at once. The paper shows that this is not always true for unweighted graphs when there are three or more colors. They provide examples where groups can jointly change colors to improve their own outcomes without improving the overall benefit, revealing a surprising weakness in group stability.
Open → 2610.04948v1

Efficient exact search methods improve finding Moore graph structures

Less is Moore

Abstract: A Moore graph simultaneously asks for two things that normally pull in opposite directions: every vertex should have many neighbors, while every pair of vertices should remain close. For diameter two and degree $k$, the Moore bound is $k^2+1$, and equality forces a remarkably rigid graph: it is strongly regular with parameters $(k^2+1,k,0,1)$. Hoffman and Singleton showed that such a graph can exist only for $k=2,3,7$, and possibly 57. The degree-57 case on 3,250 vertices remains open. This paper is not an attempt to settle that open problem. Instead, we ask a more algorithmic question: How efficiently can the defining Moore structure itself be searched exactly? We begin from a human-developed exhaustive search based on the radius-two Moore tree. Leaves fall into $k$ groups of size $k-1$, and the edges between every pair of such groups form a perfect matching - a permutation. For efficiency, a partial construction is abandoned immediately when it creates a triangle or quadrangle. We then describe a sequence of exact algorithm-engineering improvements developed through a human-guided AI process and accepted only after mathematical checking and controlled regression tests. The main steps are reversible short-cycle forbid counters, bit-parallel domains, minimum-remaining-value branching, singleton propagation, matching-based AllDifferent filtering, balanced replayable parallel frontiers, residual-symmetry orbit pruning, and canonical deduplication of frontier states. On the principal $k=9$ benchmark, stronger symmetry cuts wall time from 47.6 to 17.9 seconds on a six-core laptop setup. Further parallelization speedup is reported separately; on a 16-core/32-thread machine, median wall time is reduced to 5.28 seconds. Degrees 10 and 57 are used as stress tests, and a five-minute degree-57 run uses only 161 MiB peak resident memory, showing that state size is modest.

Sat 3 OctDiscrete Mathematics
The gist
Moore graphs are special networks where every point is well connected and close together, but they are very rare and hard to find, especially for certain sizes. The authors focus on how to quickly search for these structures using smarter algorithms, rather than proving if they exist. They improve the search by adding steps that instantly reject bad guesses and by using clever computer tricks that speed up the process on multiple processors. This helps explore the problem more efficiently while using less memory than before.
Open → 2610.04815v1

Regular tournaments missing near-complete balanced antidirected trees

Note on near-spanning balanced antidirected trees missing from regular tournaments

Abstract: We construct near-spanning balanced antidirected trees that fail to embed in highly symmetric tournaments despite the conjectured semidegree condition being satisfied. More precisely, for every sufficiently large odd integer $n$, we exhibit a regular vertex-transitive tournament on $n$ vertices and a balanced antidirected caterpillar on $n-1$ vertices with maximum degree at most $(1+o(1))n/\log_2 n$ that is not contained in the tournament. The host satisfies the strict $k/2$ threshold in both the semidegree and pseudo-semidegree settings, where $k$ is the number of arcs of the target tree. Consequently, this gives counterexamples to the uniform sublinear-degree interpretations of Conjectures~6.8 and~7.6 in Stein's survey (2024). The order $n-1$ of the target is best possible under the strict semidegree hypothesis. We also give a six-vertex balanced antidirected double-star missing from the seven-vertex Paley tournament, and show that seven is the smallest host order for a pseudo-semidegree counterexample with this fixed double-star.

Thu 1 OctDiscrete Mathematics
The gist
The paper shows that certain highly symmetric directed graphs called regular tournaments can fail to contain almost all of a particular kind of tree, called balanced antidirected trees, despite meeting expected degree conditions that should allow such embeddings. Specifically, the authors construct examples where a large tournament cannot fit a balanced antidirected caterpillar tree that is just one vertex short of spanning it. This counters some existing conjectures about the conditions needed for such embeddings. The work also includes a small specific example with a double-star tree and a Paley tournament.
Open → 2610.02390v1

Weighted matroid intersection solved faster with simple auction method

A Faster Auction Algorithm for Weighted Matroid Intersection

Abstract: We consider the weighted matroid intersection problem in the independence-oracle model. A sequence of works by Huang--Kakimura--Kamiyama [SODA'16 \& Math. Program'19], Chekuri--Quanrud [SODA'16], Quanrud [ICALP'24], and Dudeja--Grilnberger [IPCO'26] has developed efficient $(1-\varepsilon)$-approximation algorithms for this problem. We present a simple deterministic auction algorithm that, given two matroids on a common ground set of size $n$, computes a $(1-\varepsilon)$-approximate maximum-weight common independent set using $O(n \varepsilon^{-2} \log^2(n))$ independence-oracle queries. This is the first deterministic $(1-\varepsilon)$-approximation algorithm for the weighted matroid intersection problem whose query complexity is nearly linear in $n$ and polynomial in $1/\varepsilon$. Our algorithm builds on the auction algorithm for unweighted matroid intersection by Huang--Kobayashi ['26], together with the analysis of the auction algorithm for weighted bipartite matching by Liu--Ke--Khuller [APPROX'23].

Thu 1 OctData Structures and Algorithms
The gist
This paper tackles a complex problem called weighted matroid intersection, which involves finding the best shared structure from two sets. The authors present a straightforward method inspired by auction ideas that quickly approximates the best solution. Their approach significantly reduces the number of queries needed to achieve a near-best answer compared to earlier methods. This improvement is deterministic, meaning it gives consistent results every time.
Open → 2610.00920v1

Line-graph inequality reversed by attaching long paths to graphs

Reversing the Mostar line-graph inequality with long pendant paths

Abstract: Let $K_t$ be obtained by attaching a pendant path of length $t$ to a fixed rooted graph $K$. We prove that $\mathrm{Mo}(L(K_t))-\mathrm{Mo}(K_t)$, the difference between its line-graph and original Mostar indices, is exactly affine on each parity class beyond a sharp uniform cutoff. The slope depends on distance-level neighbor counts and is positive for every non-bipartite core. Triangle chains give infinitely many graphs with $\mathrm{Mo}(L(G))>\mathrm{Mo}(G)$ at every positive cyclomatic number $c$, with maximum degree three, resolving Alex-Indulal Problem 3.3. At zero slope, a cactus branch-mass formula decides equality; identical vertex profiles need not give identical intercepts. Fixed cores giving equality for all sufficiently long attachments exist exactly when $c$ is odd. Maximum degree three suffices, and at every even $c$ a binary-tree construction gives equality on one eventual parity class.

Wed 30 SeptDiscrete Mathematics
The gist
This paper studies a mathematical measure called the Mostar index that compares a graph and its line graph. The authors found that adding long pendant paths to a core graph can reverse the usual inequality between these indices under certain conditions. They precisely describe when and how this reversal happens, depending on the structure and parity of the graph. The findings also solve a previously open problem about graphs with specific cycle counts and degrees.
Open → 2610.00829v1

No 8-regular graphs with distinct triangle counts among vertices exist

There is no $8$-regular $K_3$-irregular graph

Abstract: A graph is $K_3$-irregular if its vertices belong to pairwise distinct numbers of triangles. We prove that no $8$-regular $K_3$-irregular graph exists, settling the last unresolved case. Following the initial discovery of such graphs for regularities $r \in \{10,11,12\}$ (Stevanovi'c et al., 2024), our previous work (Hak et al., 2025) showed that no such graphs exist for $r \le 7$, provided the first example for $r=9$, and proved that any $8$-regular candidate must have between $17$ and $22$ vertices. We exclude these possible orders for $r=8$ by combining careful analysis of triangle degrees with integer linear programming techniques. Meanwhile, a recent construction (Zhang, 2026) established that regular $K_3$-irregular graphs do exist for all $r \ge 9$. Together with our results, this establishes that an $r$-regular $K_3$-irregular graph exists if and only if $r\geq 9$.

Tue 29 SeptDiscrete Mathematics
The gist
Some graphs have a special property where each point (vertex) belongs to a unique number of triangles, called being triangle-irregular. The authors proved that if every point connects to exactly 8 others, such a graph cannot exist. Previous work found such graphs for 9 or more connections but none for 7 or fewer. By ruling out all possible sizes for the 8-connection case, they showed these special graphs only appear when points have at least 9 connections.
Open → 2609.37978v1

Majority coloring games solved for trees cycles and subdivisions

Structural and computational aspects of majority coloring games

Abstract: A majority coloring of a graph $G = (V,E)$ is a coloring of $V(G)$ such that, for each vertex $v$, the number of neighbors of $v$ with the same color as $v$ is at most $deg(v)/2$. A strong majority coloring is a coloring of $V(G)$ such that, for each vertex $v$, every monochromatic subset of $N(v)$ has size at most $deg(v)/2$. The (strong) majority coloring game is a two-player Maker-Breaker-type game, in which two players Alice and Bob color the vertices of a graph $G$ alternately, maintaining the (strong) majority condition. The least number of colors such that Alice has a winning strategy in such a game is called the (strong) majority game chromatic number of the graph $G$, denoted $μ_g(G)$ (or $\mathrm{Maj}_g(G)$ for the strong version). For the majority coloring game, we prove that $μ_g(G) \le 3$ under the following cases: $G$ is a $2$-caterpillar, $G$ is a rooted tree with all leaves at depth $k \le 4$, and $G$ is a subdivision of some graph. The latter resolves a problem posed by Bosek--Grytczuk--Jakóbczak in 2019, who also asked whether $μ_g(T) \le 3$ for every tree $T$. For the latter question, we discuss various difficulties that arise when natural strategies are attempted by Alice to win the majority coloring game on trees. We include a comparison with the marking game and relaxed coloring game on trees, and with the majority coloring game on locally finite acyclic graphs $G$ with $δ(G) > 1$. For the strong majority coloring game, we compute $\mathrm{Maj}_g(C_n)$ exactly for each cycle $C_n$, $n \ge 3$. We also initiate the study of the computational complexity of the strong majority coloring game; specifically, we prove that the decision version of the Strong Majority Game Chromatic Number problem is PSPACE-complete. We also show that the Strong Majority 2-Coloring problem is NP-complete on Eulerian graphs.

Tue 29 SeptDiscrete Mathematics
The gist
This paper studies a game where two players color the dots (vertices) on a network (graph) so that no dot shares a color with more than half its neighbors. The authors identify cases where three colors always let the first player win, such as certain trees and graphs made by dividing edges. They also find the exact number of colors needed for cycles and show that deciding these colorings in some settings is computationally very hard. Their work advances understanding of how such coloring games behave on different graph shapes.
Open → 2609.37796v1

Matroid packing games provide efficient fair allocation methods

Matroid Packing Games: The Core and the Nucleolus

Abstract: In this paper, we study the matroid base packing problem from the perspective of cooperative game theory and define the associated matroid base packing game. This model extends the network strength game of Baiou and Barahona (2020) from graphic matroids to general matroids. Building on the exchange structure of matroid, we develop a graph theoretic framework for analyzing the core and the nucleolus in this game. This framework yields a compact characterization of core nonemptiness and enables polynomial time algorithms for testing core nonemptiness, finding a core allocation, and computing the nucleolus. In particular, the approach provides a broader and more structured framework for the nucleolus computation problem arising in network strength games studied by Baiou and Barahona (2020), covering both the nonempty core and empty core cases.

Tue 29 SeptComputer Science and Game Theory
The gist
Matroid packing problems involve selecting groups of elements without overlap, with many real-world uses. The researchers study these problems through cooperative game theory to find fair ways to share resources. They create a method to check when fair divisions exist and how to find the best fair division efficiently. Their approach works for broad cases beyond previous network-specific models, even when fair solutions are hard to find.
Open → 2609.37278v1

Graphs with bounded partitions admit precise simplified representations

Additive Quasi-isometry via rooted graph partitions and layering partition

Abstract: For a graph $H$, $\langle H \rangle$ denotes the class of all subdivisions of $H$ and $tw(H)$ denotes the treewidth of $H$. In this paper, we prove the following. For $k\geq 1, R\geq 1$, let $G,H$ be two graphs such that strong isometric path complexities (Chakraborty et al. [\textsc{Disc. Math., 2026}]) of both $G$ and $\langle H \rangle$ are at most $k$, and $G$ admits an honest, ``nicely rooted'' $R$-bounded $H$-partition. Then, there is a graph $F$ with $tw(F)\leq tw(H)$ such that $G$ admits a $(1,33\cdot R\cdot k^2)$-quasi-isometry to $F$. Using results of Albrechtsen, Distel, and Georgakopoulos (2025), we also obtain that $K_{2,t}$-asymptotic minor-free graphs admit quasi-isometries with additive distortion to $K_{2,t}$-minor-free graphs. This answers an open question raised by the above authors. As part of our proof, we combine the graph-partition based method and the layering partition based method (Chepoi et al. [\textsc{Discrete Comput. Geom.} 2012]) to obtain additive quasi-isometry when both the source and all subdivisions of the target graph have bounded strong isometric path complexity.

Mon 28 SeptDiscrete Mathematics
The gist
This paper studies when one complex network can be closely approximated by a simpler network, where distances between points are preserved up to a small fixed amount. The authors show that if a graph and certain variations of another have limited complexity in how shortest paths behave, and the first graph can be nicely divided based on the second, then there is a simpler graph similar enough to the first one. They also answer an open question about networks that avoid certain complicated subgraphs, proving these can be approximated well by simpler networks with the same kind of restrictions.
Open → 2609.36186v1

Weighted ultrametric embedding with outliers gets better approximation

A $5/2$-Approximation for Weighted Ultrametric Embedding with Outliers

Abstract: Weighted ultrametric embedding with outliers asks for a minimum weight set of points whose deletion makes the remaining metric an ultrametric, equivalently, leaves no triple with a unique largest distance. We give a deterministic $5/2$-approximation using $O(n^5)$ arithmetic and comparison operations, improving the previous factor $3$ for arbitrary nonnegative vertex weights. Approximating the problem within any factor strictly below $2$ is UGC-hard.

Mon 28 SeptData Structures and Algorithms
The gist
The problem is about finding a small weighted set of points to remove so that the remaining distances between points behave like a special type of metric called an ultrametric. This means no group of three points has a unique largest distance, which helps structure data in hierarchical ways. The authors improved the best approximation algorithm from a factor of 3 to 2.5, meaning their solution is closer to the best possible answer. They also note it’s very hard to get better than a factor of 2 by known complexity assumptions.
Open → 2609.35235v1

Vertex integrity solved faster than two to the power n time

Solving Vertex Integrity Faster than $2^n$

Abstract: The vertex integrity of a graph $G$ is the minimum of $|S|+\max_{C\in\operatorname{cc}(G-S)}|V(C)|$ over all vertex sets $S\subseteq V(G)$, where the maximum is zero if $G-S$ is empty. We study its exact exponential complexity in terms of $n=|V(G)|$. First, we give a reduction from Vertex Cover on subcubic graphs that increases the number of vertices by only a constant factor. Consequently, unless the Exponential Time Hypothesis fails, Vertex Integrity admits no $2^{o(n)}n^{O(1)}$-time algorithm. We also give a deterministic exact algorithm running in $O(1.9602^n)$ time and space, improving on the direct $O^*(2^n)$ algorithm. Its key ingredients are a balanced partition of the components left by an optimal irredundant separator and a subset dynamic program restricted to sets of at most $\lceil 2n/5\rceil$ vertices. An optimal separator can be recovered within the same bounds.

Sun 27 SeptData Structures and AlgorithmsDiscrete Mathematics
The gist
Vertex integrity measures how to split a graph by removing some points so that the largest remaining group is small. The authors show that this problem cannot be solved significantly faster than checking all possibilities unless a famous hypothesis is false. They also develop a new algorithm that runs faster than the straightforward method by smartly breaking down the graph and using advanced dynamic programming. This approach improves exact computations on graphs and can also find an optimal splitting set efficiently.
Open → 2609.33779v1

Proof confirms maximum size for binary linear subspace codes

A proof of the Braun-Etzion-Vardy bound for binary subspace codes

Abstract: The notion of a linear subspace code in a projective space was introduced by Braun, Etzion and Vardy (2013), who conjectured that a linear subspace code in the projective space has at most 2^n codewords. We resolve this conjecture. A novel character-theoretic argument is used to prove the conjecture and the proof is self-contained.

Sun 27 SeptInformation Theory
The gist
Subspace codes are special sets used in coding theory to handle errors in data transmission. Braun, Etzion, and Vardy guessed these sets can only reach a certain size, specifically 2 to the power of n elements. This paper confirms their guess is true by using a new mathematical proof based on character theory. The proof is complete on its own and does not need outside results.
Open → 2609.33719v1

Potts model shows robust root label reconstruction despite noise

Robust Reconstruction on Trees with a Growing Alphabet

Abstract: We study robust reconstruction for the \(q\)-state Potts broadcast process on a Galton-Watson tree in the growing-alphabet regime \(q\to\infty\), with boundary depth growing sufficiently quickly in relation to \(q\). We show that, in the regime \(dλ>1\), where \(d\) is the expected number of offspring and \(λ\) is the nontrivial eigenvalue of the Potts transition matrix, the root posterior is asymptotically unchanged by a broad class of noise channels applied independently to the boundary labels. This remains true even when the probability of retaining the true label at an individual boundary vertex tends to zero as \(q\to\infty\). More precisely, under suitable moment and noise assumptions, the noiseless and noisy root posteriors converge to one another in expected total variation, and hence have the same asymptotic Bayes-optimal reconstruction accuracy.

Sun 27 SeptInformation Theory
The gist
This paper studies how to figure out the original label at the root of a complex tree structure when the number of possible labels becomes very large. The authors find that even when the labels observed at the edges are heavily corrupted by noise, the original label’s prediction remains accurate under certain conditions. This means the system can tolerate a lot of uncertainty or errors at the boundary without losing important information about the root. Their work applies mathematical tools to understand how information survives in noisy hierarchical settings.
Open → 2609.33263v1

Complexity results for orienting acyclic mixed graphs with branching paths

Acyclic orientations of mixed graphs

Abstract: A mixed graph $M=(V,E\cup A)$ is acyclic if its directed part $(V,A)$ is an acyclic digraph. In this note we study the so-called orientation completion problem for the class of acyclic mixed graphs. That is, given an acyclic mixed graph $M$ and a property ${\cal P}$; can we orient the edges of $M$ so that the resulting digraph is acyclic and has property ${\cal P}$. We prove that one can decide in polynomial time whether $M$ can be completed to an acyclic digraph with an out-branching from a prescibed vertex $s$, while it is NP-complete to decide whether $M$ has an acyclic orientation which has both an out-branching and an in-branching (a bipolar orientation). We show that it is NP-complete to decide whether $M$ can be oriented so that it contains a directed path between two prescribed vertices. Finally we describe a polynomial algorithm for deciding whether an acyclic digraph $D$ has an out-branching $B^+_s$ such that the digraph $D-A(B^+_s)$ is connected (in the underlying sense). Based on this we pose as an open problem the complexity of deciding whether the edges of an acyclic mixed graph can be oriented so that the result is an acyclic digraph with a non-separating out-branching.

Sat 26 SeptDiscrete Mathematics
The gist
The authors studied how to give directions to undirected edges in mixed graphs that already have some directions, without creating loops. They found ways to tell quickly if a graph can be directed to have a certain kind of tree with paths starting from a specific point. But they also showed that figuring out if the graph can have more complex structures like trees branching in both directions or paths between two chosen points is much harder. Lastly, they gave a method for checking a certain connectivity property related to those branchings and posed a question about its complexity.
Open → 2609.32403v1

Binary rank limits found for matrices with fixed real rank

On the Binary Rank of Matrices with Constant Real Rank

Abstract: We continue the study initiated by Parnas and Shraibman~\cite{PARNAS2026264} who gave upper bounds on the binary rank of $0,1$ matrices which have a small rank over the reals. We give alternative completely mathematical proofs of results proved in~\cite{PARNAS2026264} with the assistance of a computer program, and also solve one of the open problems presented there regarding the maximal binary rank of a matrix with real rank $5$. Moreover, our techniques provide a general method for giving non-trivial upper bounds on the maximal binary rank of a matrix with constant real rank. Our results also imply bounds on the equivalent problem of finding the minimum number of bicliques needed to partition the edges of a bipartite graph whose reduced adjacency matrix has real rank at most $d$.

Thu 24 SeptDiscrete Mathematics
The gist
Some math researchers studied a special kind of matrix that contains only zeros and ones but also has a fixed rank when using normal real numbers. They found new ways to show upper limits on the ‘binary rank’, which measures how complex the matrix is in a different way. They solved an open problem for matrices with real rank 5 and created general methods that work for other fixed ranks too. Their work also relates to how we can break down connections in certain graphs efficiently.
Open → 2609.30203v1

Smoothness in weakly modular graphs identified by forbidden subgraphs

Smooth weakly modular graphs

Abstract: A graph $G=(V,E)$ is called smooth (respectively, strongly smooth) if for any two vertices $u,v\in V$, the distance point-shadow $v|u := \{ x\in V: d(u,x)=d(u,v)+d(v,x)\}$, respectively, the point-shadow $v/u := \{ x\in V: v\in\mathrm{conv}(u,x)\}$, is geodesically convex. Smooth graphs have been introduced by Nebeský (2005) in the context of step systems. Graphs with convex point-shadows and convex distance point-shadows also naturally occur in convexity theory. Brešar et al. (2026) recently showed that several classes of graphs are smooth and that smoothness is preserved by Cartesian products, gated amalgams, and isometric subgraphs. Weakly modular graphs comprise the most important classes of graphs from Metric Graph Theory: median, modular, Helly, bridged, and dual polar graphs. In this note, we characterize smooth and strongly smooth weakly modular graphs in terms of forbidden isometric subgraphs on 5 and 7 vertices. This settles Problem 1 of the paper by Brešar et al. We also characterize prime strongly smooth weakly modular graphs, i.e., strongly smooth weakly modular graphs that cannot be obtained from smaller graphs by Cartesian products and gated amalgams.

Thu 24 SeptDiscrete Mathematics
The gist
This paper studies special properties called smoothness and strong smoothness in graphs, where certain groups of points behave nicely with distances. The authors focus on a big class of graphs important in metric graph theory and find exact small patterns that cannot appear if these properties hold. They also identify graphs that are building blocks for strongly smooth graphs, helping understand their structure better. These results solve a previously open problem in the area.
Open → 2609.30035v1

Fast algorithm finds disjoint paths in graphs on complex surfaces

Linear-Time FPT Algorithm for Surface Disjoint Paths via Surface Cutting

Abstract: We study the \textsc{$k$-Disjoint Paths} problem on a graph embedded on a surface with bounded Euler genus. Given a graph $G$ with $n$ vertices and $k$ vertex pairs embedded on a surface of Euler genus $g$, we present a $2^{O(k^2+g^2)}n$-time algorithm that computes $k$ pairwise vertex-disjoint paths connecting the given vertex pairs if such paths exist. Our approach relies on the decomposition of $G$ into $O(k+g)$ planar subgraphs while bounding the complexity of the boundaries between these subgraphs. This approach enables the use of techniques for compressing linkages in planar graphs. Moreover, our techniques yield two kernels of size polynomial in $k$, $g$, and the treewidth of the graph, and of size $2^{O(k+g)}$. These results extend recent advances on \textsc{$k$-Disjoint Paths} on planar graphs [Cho et al. SODA 2023] and [Włodarczyk and Zehavi FOCS 2023] to surface-embedded graphs.

Thu 24 SeptData Structures and AlgorithmsComputational Geometry
The gist
Finding multiple routes that don’t cross each other on a map-like structure can be very tricky, especially when the map is drawn on complicated surfaces like a donut shape. The authors developed a new method that quickly solves this problem for maps drawn on surfaces with a certain complexity measure called Euler genus. They break the complex surface into simpler flat parts and use clever techniques to stitch paths together without overlaps. Their work extends previous solutions from flat surfaces to more complex ones.
Open → 2609.29324v1

Deterministic polynomial kernel accelerates odd cycle transversal problem

A Deterministic Polynomial Kernel for Odd Cycle Transversal

Abstract: We give a deterministic polynomial kernel for Odd Cycle Transversal, derandomizing the randomized kernel of Kratsch and Wahlström (TALG 2014). Our algorithm uses a deterministic polynomial-time construction of almost multilinear representations of gammoids. Such a representation assigns a block of columns to each element so that, for every subset of elements, the normalized matrix rank approximates its matroid rank to within a prescribed additive error $δ$. The construction builds on recent breakthroughs in NC algorithms for matching. Our kernelization algorithm then computes the required representative families from these representations.

Thu 24 SeptData Structures and Algorithms
The gist
The paper deals with a puzzle in computer science called the Odd Cycle Transversal problem, which involves finding and removing certain odd loops in a network. The authors developed a method to simplify this problem into a smaller version that’s easier to solve and does it deterministically, without relying on chance. They achieved this by using a mathematical structure called gammoids and advanced ways to represent them efficiently. This makes solving or approximating the problem more practical in polynomial time.
Open → 2609.29141v1

New upper bound found for tetrahedron Turán density problem

A New Upper Bound for the Turán Density of the Tetrahedron

Abstract: We prove that the Turán density of the tetrahedron $K_4^{(3)}$ satisfies $π(K_4^{(3)}) \le 312372062889819/560000000000000 < 0.557808$, improving Baber's upper bound of $0.5615$ and closing about $62\%$ of the gap to the conjectured value $5/9$. The proof uses an exact seven-vertex flag-algebra certificate incorporating degree-stationarity from Razborov's differential method. To find the certificate, we combine the established techniques of cutting planes and column generation to optimize jointly over flag families whose types have at most five vertices. We give a complete formal proof of this Turán density bound in Lean 4.

Wed 23 SeptDiscrete Mathematics
The gist
The paper studies a mathematical problem about how densely a certain pattern called a tetrahedron can appear in a large 3-dimensional network. The authors improve the known upper limit on this density, bringing it closer to a long-standing conjecture. They use advanced mathematical tools and computer-assisted proof techniques to achieve this improvement and provide a fully formalized proof.
Open → 2609.27495v1

Longer snake paths and better asymptotic bounds found in hypercubes

Constructing longer snakes and improved asymptotic bounds in hypercubes

Abstract: We give snakes that are longer than the previous best known in dimensions 13 through 20 and improve the general lower bound for every dimension $d \geq 21$. Our explicit snakes reach 371,711 edges in dimension 20. Twenty compatible paths in that cube allow generalisation to give snakes of length at least $(17/48)2^d$ for every $d \geq 21$. Their controlled overlaps allow copies to be joined across the layers of a larger cube without creating shortcuts. Four additional paths give the same bound for coils. We explain the construction, prove the joining rule, and then count its length. The finite paths and their required intersections are independently verifiable.

Wed 23 SeptDiscrete Mathematics
The gist
This paper deals with the problem of finding very long paths called snakes inside hypercubes, a type of high-dimensional network structure. Longer snakes mean better lower bounds on how long such paths can be in larger hypercubes. The authors present new snakes that exceed previous length records in dimensions 13 to 20, and then use them to prove improved general lower bounds for any dimension 21 or higher. Their approach involves combining multiple paths with careful overlaps to build even longer ones without shortcuts.
Open → 2609.27483v1

Exact cardinality approximation for max min metric t join problem

Remote Matching: Exact-Cardinality Approximation and Tight UGC Hardness

Abstract: In the unrestricted max--min metric $T$-join problem, one seeks an even terminal set $T$ maximizing the cost of a minimum $T$-join. Iwata and Ravi gave a factor-$3/2$ approximation for this problem. We show that this guarantee is tight under the Unique Games Conjecture: no polynomial-time approximation with factor strictly smaller than $3/2$ exists under UGC. We then consider the exact-cardinality variant, which prescribes an even number \(k\) of terminals. Writing \(p:=k/n\), we give a deterministic polynomial-time \(ρ(p)\)-approximation for every feasible cardinality, where \[ ρ(p)= \begin{cases} 7/2, & \makebox[1.5em][r]{$0$}<p\le2/7,\\ 1/p, & 2/7\le p\le2/3,\\ 1/[2(1-p)], & 2/3\le p\le7/8,\\ 4, & 7/8\le p<1. \end{cases} \] In particular, a factor-\(4\) approximation holds throughout the entire feasible cardinality range, the factor is at most \(7/2\) whenever \(0<k\le 6n/7\), and equals \(3/2\) at \(k=2n/3\). The algorithmic framework is based on optimal laminar cut packings, their weighted tree representations, exact-cardinality rounding, and tree dynamic programming.

Tue 22 SeptData Structures and Algorithms
The gist
This paper studies a complicated math problem where you want to connect specific points in a network so that the total connecting cost is as large as possible, under certain rules. Earlier work gave a way to approximate this solution within 1.5 times the best possible, and this paper shows that this is the best you can do unless a famous complexity conjecture is false. They also handle a more exact version where the number of points to connect is fixed and give methods that change based on that number. Their algorithms use advanced techniques involving cutting networks into pieces and smart ways to combine these pieces.
Open → 2609.26671v1

Graphs with large odd cycles need minimum connections for small triangle-free mappings

Asymmetric Homomorphism Thresholds for Graphs of Large Odd Girth

Abstract: We determine the asymmetric homomorphism threshold from graphs of odd girth at least $7$ to triangle-free graphs, showing that $δ_{\mathrm{hom}}(\{C_3,C_5\},\{C_3\})=\frac{1}{9}$. Equivalently, for every $\varepsilon>0$, every $n$-vertex graph of odd girth at least $7$ and minimum degree at least $(1/9+\varepsilon)n$ admits a homomorphism to a triangle-free graph of size bounded by a function of $\varepsilon$, while there exist graphs of odd girth at least $7$ and minimum degree at least $(1/9-\varepsilon)n$ for which no such bounded-size triangle-free homomorphic image exists. More generally, for every $t\geq 3$, we prove $δ_{\mathrm{hom}}(\{C_3,C_5\},\{K_t\})=\frac{1}{3t}$. In particular, for every proper monotone class $\mathcal C$ of graphs, the threshold for graphs of odd girth at least $7$ to admit a homomorphism to a bounded-size graph in $\mathcal C$ is positive. We further extend this phenomenon to arbitrary odd girth: for every $k\geq 2$ and every proper monotone subclass $\mathcal C$ of the class of graphs of odd girth at least $2k-1$, the threshold for graphs of odd girth at least $2k+3$ to admit a homomorphism to a bounded-size graph in $\mathcal C$ is positive. These results disprove conjectures of Gishboliner, Hurley and Wigderson and exhibit a sharp contrast with the corresponding zero chromatic-threshold results. Our lower-bound constructions are based on high-dimensional Borsuk graphs, while the matching upper bounds use regularity arguments to recover the structure underlying these constructions.

Mon 21 SeptDiscrete Mathematics
The gist
The authors studied special large graphs that avoid certain small odd cycles and explored how connected these graphs must be to simplify them into triangle-free graphs with a limited size. They found exact numbers that show when this simplification is possible and when it is not. Their results disprove previous guesses and reveal surprising differences compared to related graph coloring problems. The work uses advanced mathematical tools, including geometric constructions and combinatorial methods, to prove these properties.
Open → 2609.25390v1

Polynomial time methods yield improved graph signings and partitions

Kadison--Singer partitions and Bilu--Linial graph signings in polynomial time

Abstract: We prove two main algorithmic results in spectral discrepancy. First, we give a deterministic polynomial-time rounding theorem for rational positive semidefinite matrices of arbitrary rank. The algorithm starts from any rational fractional signing and assigns one sign per original matrix. Its discrepancy is less than $3.37\,\|\sum_i \mathrm{Tr}(A_i)A_i\|^{1/2}$. This yields Kadison--Singer half-partitions with error below $1.69\sqrt{\varepsilon}$, as well as deterministic graph signings that control signed adjacency and signed degrees simultaneously. The proof builds on the spectral-potential method of Ezeunala and Jiang (2026) and introduces a new way to choose rounding directions. We prove polynomial bit complexity for the rounding procedure. Second, we give a Las Vegas algorithm for the Bilu--Linial signing problem on an arbitrary prescribed graph. If $G$ has $n$ vertices and maximum degree $Δ\ge3$, the algorithm terminates almost surely. It uses fewer than $100n^3$ insertion attempts in expectation and returns a signing with $\|A_s\|<2\sqrt{2(Δ-1)}$. For bipartite graphs its one-sided form gives the sharp universal bound $\|A_s\|<2\sqrt{Δ-1}$. The algorithm builds the signing by inserting vertices and recursively deleting and restoring neighbors after rejected insertions. In the analysis, the $\sqrt2$ gap to the Bilu--Linial conjecture comes from a factor of two in the bound for vertex deletions in the two-sided case. On a $d$-regular bipartite Ramanujan base the same signing produces a Ramanujan $2$-lift of that prescribed base.

Sun 20 SeptData Structures and Algorithms
The gist
The paper deals with how to assign signs (+ or -) to parts of mathematical objects called matrices and graphs in a way that keeps certain balances or errors low. The authors developed algorithms that can efficiently find such signings with guaranteed error bounds. One method works on general matrices and gives deterministic results, while the other handles graphs and uses randomness to achieve signings that nearly meet a famous theoretical bound. These advances help solve long-standing mathematical problems related to graph structures and matrix partitions.
Open → 2609.23855v1

Improved connectivity bounds for spanning bipartite subgraphs in networks

An $O(k\log(n/k))$ Bound on Spanning Bipartite Connectivity

Abstract: For integers $1\le k\le n/2$, let $f(k,n)$ be the least integer $s$ such that every $s$-connected graph on $n$ vertices contains a spanning bipartite $k$-connected subgraph. Thomassen conjectured that $f(k,n)$ is bounded by a function of $k$ alone. Delcourt and Ferber proved $f(k,n)=O(k^3\log n)$, and Yuster subsequently obtained $f(k,n)\le22k^2\log_2 n$. We prove that, for $2\le k\le n/2$, \[ f(k,n)\le\min\left\{n-1,\, \left\lfloor6(k-1)\log_2\frac{n}{k-1}\right\rfloor\right\}. \] In particular, $f(k,n)=O(k\log(n/k))$.

Sun 20 SeptDiscrete Mathematics
The gist
This paper looks at how well connected a network must be to ensure it contains a special kind of sub-network called a spanning bipartite k-connected subgraph. The authors improve previous mathematical bounds on the minimum connectivity needed. Their result shows you can guarantee this kind of sub-network exists if the network’s connectivity grows roughly like k times the logarithm of the network size divided by k. This refines earlier results and gets closer to a long-standing conjecture.
Open → 2609.23262v1

Online algorithms for directed network design cannot beat exponential limits

Hardness of Online Directed Steiner Network

Abstract: In the Directed Steiner Network (DSN) problem we are given a directed graph and a set of demands $(s_i,t_i)$, and asked to find a cheap subgraph connecting each terminal pair. In its online version, the demands arrive online and must be served by buying edges irrevocably. DSN is a fundamental hard problem in network design, heavily studied in both the offline and the online setting. Offline, it has a superpolylogarithmic hardness of approximation. However, offline hardness says nothing about online algorithms, which are computationally unrestricted. It has been an open question whether uncertainty itself (needing to commit to a solution without knowing future demands) rules out polylogarithmic-competitive online algorithms. In this work, we show the first such unconditional, information-theoretic hardness. Namely, we give an $\exp\!\bigl(Ω(\sqrt{\log n})\bigr)$ bound on the competitive ratio, which holds even for randomized algorithms against an oblivious adversary, and on unit-cost DAGs. Our proof uses a novel connection between online network design and algebraic coding theory. We encode requests using a hidden low-degree polynomial, whose past evaluations reveal nothing about future ones. We then use list-recovery bounds to show that an algorithm cannot make cheaply reusable decisions without knowing those future evaluations.

Fri 18 SeptData Structures and Algorithms
The gist
The problem is about connecting pairs of points in a directed network in the cheapest way possible. The authors study when these connection requests come one by one, and decisions must be made without knowing future requests. They show that no online method can do much better than a certain expanding exponential cost compared to the best offline method. This result uses ideas from algebraic coding to prove that decisions made early can’t be cheaply reused without knowing what’s coming next.
Open → 2609.22605v1

Algorithms find best meeting points fast on directed graphs

When Shall We $k$ Meet Again? Tight Algorithms for Diameter and Radius under the Meet Distance

Abstract: Finding an optimal meeting point for a collection of agents on a directed graph is a classical problem studied in the context of network analysis, operations research and computational geometry. In this work, we use the two objectives of optimal meeting points examined in the literature to study two notions of meet-distance: $d^{\max}(u,v)$, the minimum over all meeting points $w$ of $\max(d(u,w), d(v,w))$; and $d^+(u,v)$, the minimum over all meeting points of $d(u,w) + d(v,w)$. These values measure the minimum time and minimum total distance required for two agents to meet. We initiate the fine-grained study of fundamental graph parameters under the two notions of meet-distance, namely the diameter, radius and eccentricities. For general directed graphs, we give an $\tilde{O}(m\sqrt{n})$ time algorithm for computing a 2-approximation to both notions of meet-diameter and show that this result is optimal under SETH. In contrast, we show that such a result is unattainable for the meet-radius as any finite approximation requires quadratic time under the Hitting Set Conjecture. For directed acyclic graphs, we obtain stronger results. We compute the meet$^{\max}$-diameter exactly in linear time and give a linear-time $2$-approximation for the meet$^{+}$-diameter. We complement the latter with a quadratic-time lower bound for any $(3/2-\varepsilon)$-approximation under SETH, yielding a separation between the two meet-distance objectives. Finally, we study the generalized meet-distance of $k$-tuples of vertices. For every positive integer $\ell$, we reduce the problem of $\ell$-approximating the $k$-point meet-diameter to computing an exact meet-diameter on smaller tuples, obtaining an $\ell$-approximation in time \[ O\!\left( mn+ \ell \left\lceil k^{1/\ell}\right\rceil n^{\left\lceil k^{1/\ell}\right\rceil+1} \right). \]

Fri 18 SeptData Structures and Algorithms
The gist
Finding the best place for two or more agents to meet on a directed graph is a tricky puzzle with different ways to measure the best spot. The authors study two main ways: one that minimizes the longest travel time for either agent, and one that minimizes the total travel time combined. They designed new algorithms to quickly approximate or exactly find these meeting points and proved limits on how fast these algorithms can be under popular complexity assumptions. They also extended their ideas to meetings involving more than two agents, revealing how the difficulty grows with the number of participants.
Open → 2609.22569v1

Matroid secretary problem solved for linear matroids with 1 over e guarantee

The Strong Secretary Conjecture is True for Linear Matroids

Abstract: We prove a $1/e$ guarantee for the matroid secretary problem on linear matroids, therefore settling the strong secretary conjecture in this class of matroids. The result holds both when the matroid is known in advance and when a linear representation over a finite field is given online. In the known-matroid model, the result extends more generally to matroids admitting a finitary modular extension. Each element of a fixed optimal basis is selected with probability at least $1/e$. $\mathbf{\text{Concurrent Discovery Disclosure:}}$ The proof of the main result in this manuscript was obtained in a conversation with ChatGPT-6 Astra on Tuesday, September 15, 2026 at 1:02 AM PDT. We then prepared this manuscript for public release, with the intent of uploading it on the morning of Thursday, September 17, 2026. In the early morning hours of September 17, while finalizing the submission, we discovered the manuscript https://arxiv.org/abs/2609.19118 of Abdi, Banihashem, Hajiaghayi, and Mittal, uploaded on September 16, 2026, which contains the same result via an essentially identical approach. We are sharing our manuscript nonetheless in case our exposition is of independent utility to the community, and we hope this experience stimulates broader discussion about concurrent discovery in the AI era.

Thu 17 SeptData Structures and Algorithms
The gist
The matroid secretary problem is about choosing the best combination of items when they arrive one by one in random order, without knowing the future. This paper proves that for linear matroids—a kind of mathematical structure used to model independence—the authors can select each optimal item with at least a 1/e (around 37%) chance. This confirms a long-standing conjecture for this class of problems. Their approach works both when the matroid is fully known in advance and when it is revealed step-by-step over a finite field.
Open → 2609.20797v1

Every graph with enough connections must contain all small trees

The Erdős--Sós Theorem

Abstract: We present an exposition of a proof, discovered by GPT-6 Astra, of the Erdős--Sós Conjecture, which states that every graph with average degree greater than $t-2$ contains every tree on $t\geq 2$ vertices.

Tue 15 SeptDiscrete Mathematics
The gist
The paper explains a mathematical proof for a long-standing idea about networks, called the Erdős--Sós Conjecture. This idea says that if a network has enough connections on average, it will always include every kind of tree-shaped sub-network of a certain size. The authors show that when the average number of connections is higher than a specific threshold, every tree with that many points is guaranteed to be inside. This proof was discovered using a powerful AI called GPT-6 Astra.
Open → 2609.17877v1

Weak partition connectivity in hedgegraphs proven NP complete problem

The Complexity of Weak Partition Connectivity in Hedgegraphs

Abstract: We prove that the integer-threshold decision problem for weak partition connectivity in hedgegraphs is NP-complete, answering an open question about its computational complexity. Hardness holds even for connected unweighted hedgegraphs in which every hedge consists of exactly two nonempty, vertex-disjoint hyperedges whose union is the entire vertex set. On the same class of instances, hedge connectivity has a simple exact formula. Using a binary matrix representation, we express fractional weak partition connectivity as $m-ρ(A)$, where $ρ(A)$ maximizes the ratio of the number of selected rows to one less than the number of distinct projected columns. This formula yields both the hardness reduction and deterministic algorithms: exact computation when some reference column gives row supports satisfying a linear intersection condition, including the case of minimum row-support number $s(A)\le2$, and a partition-output polynomial-time approximation scheme (PTAS) for both the integer and fractional objectives on all full-support split systems. Unless $\mathrm{P}=\mathrm{NP}$, neither objective admits a fully polynomial-time approximation scheme (FPTAS) on this class.

Mon 14 SeptData Structures and Algorithms
The gist
This paper studies a type of complex network called hedgegraphs and shows that deciding a property called weak partition connectivity is a hard computational problem (NP-complete). The authors found a formula to describe this property using a matrix, from which they designed exact algorithms in some cases and approximation schemes in others. They also discovered that some widely desired efficient approximations are impossible unless a major open question in computer science is resolved. Their work clarifies when and how this connectivity measure can be computed or approximated.
Open → 2609.14932v1

Johnson graphs maintain strong paths despite multiple failures

Fault-tolerant Hamiltonian connectivity of Johnson graphs

Abstract: Johnson graphs $J(n,k)$ are a classical family of highly symmetric networks known to be Hamiltonian-connected in the fault-free setting. In this paper, we investigate their Hamiltonian connectivity under three failure models, namely general edge faults, matching faults, and vertex faults. For general edge faults, we prove that $J(n,k)$ remains Hamiltonian-connected after the deletion of any set of at most $k(n-k)-3$ edges for $n\geq4$. Since $J(n,k)$ is $k(n-k)$-regular, this attains the natural degree-based upper bound for Hamiltonian connectivity. We then consider matching faults, which exclude the concentration of multiple faulty links at a single vertex and permit substantially larger fault sets. We show that $J(n,k)$ remains Hamiltonian-connected after the deletion of an arbitrary matching for $n\geq5$, including a perfect matching whenever one exists. For vertex failures, we prove that $J(n,k)$ is $(n-2)$-vertex-fault-tolerant Hamiltonian-connected for $n\geq5$. All three results are constructive and lead to recursive fault-tolerant Hamiltonian routing algorithms. Simulation results on Johnson graphs with up to $12{,}870$ vertices further show that the routing algorithms successfully construct fault-free Hamiltonian paths for all tested source-destination pairs, with measured execution times exhibiting near-linear growth with network size. These results establish a unified fault-tolerant Hamiltonian-connectivity framework for Johnson graphs under different failure patterns.

Fri 11 SeptDiscrete Mathematics
The gist
Johnson graphs are special network structures where any two points can be connected by a path that visits every node exactly once. This paper shows that even if some connections or points fail or are removed, these networks still allow such special paths to exist in many cases. The authors provide ways to find these paths efficiently even after different types of failures. Their work includes tests on large networks, showing the methods work well and quickly.
Open → 2609.12617v1

Framework improves solutions for uncertain hard optimization problems

A Reusable Framework for Robust Approximation Algorithms in the Interval Uncertainty Model

Abstract: Robust optimization under interval uncertainty aims to compute solutions that perform well on a range of scenarios that are described by interval-constrained costs. In this paper, we revisit a framework introduced by Ganesh, Maggs and Panigrahi in 2020 to study the robust optimization of NP-hard problems under interval uncertainty. We start by generalizing a result in the $\ell=0$ case, which transforms a category of approximation algorithms into a robust approximation algorithm. Furthermore, in the general case, we provide a theorem that turns any local search-based approximation algorithm into a robust approximation algorithm under three newly formalized conditions over the moves of the local search algorithm. We then use this result to present the first robust approximation algorithm for Weighted $k$-Set Cover, the third NP-hard problem known to admit a robust approximation, and the first since the publication of Ganesh, Maggs and Panigrahi's paper.

Thu 10 SeptData Structures and Algorithms
The gist
Finding good solutions when there is uncertainty about important costs is hard, especially for complex problems. The paper builds on previous work to create a reusable way of turning existing approximate solving methods into ones that handle uncertainty better. It introduces new conditions for adapting local search approaches and demonstrates the first robust method for a specific problem called Weighted k-Set Cover. This advance adds to a small set of difficult problems known to have reliable approximate solutions under uncertain conditions.
Open → 2609.11621v1

Agents coordinate treasure hunt on constantly shuffled ring networks

Online Treasure Hunt in Vertex-Permuted Dynamic Rings

Abstract: We study the problem of treasure hunt by a group of $k \geq 1$ agents in vertex-permuted dynamic rings (VP). In this model, the $n$ vertices remain on a ring but are permuted at each time step. We first show that treasure hunt is impossible for any $k \leq n-3$ agents, if there are no restrictions on the sequence of permutations used in the dynamic ring. We then study the $VP(δ)$ setting, in which for every pair $i, j$ of vertices, the edge $(i, j)$ is guaranteed to appear within $δ$ steps. We show that the class $VP(δ)$ is feasible only for $δ\geq \left\lceil \frac{n-1}{2}\right\rceil$. For the one-agent case, we show a tight bound of $Θ(δn)$ on the worst-case search time as well as competitive ratio of any online algorithm for treasure hunt, provided $δ\geq 2n$. We then give an optimal algorithm for $k$ agents, thereby showing that $k$ agents can obtain a speedup of $k$ on the worst-case search time. Finally, in the R-VP setting, in which in every step, the vertices are arranged as a ring according to a random permutation, we show that treasure hunt takes expected $Θ(n)$ steps against an oblivious adversary and $Θ(n \log n)$ steps against an adaptive adversary.

Thu 10 SeptDistributed, Parallel, and Cluster ComputingComputational Complexity
The gist
This paper looks at how a group of agents can find a hidden 'treasure' on a ring of points where the connections between points change constantly by rearranging the order of the points. The authors show that if the rearrangements are completely unrestricted, it’s impossible for almost all groups of agents to guarantee finding the treasure. Then they find conditions where it’s possible and study how long it takes for one or more agents to succeed. They also analyze cases where the rearrangement is random and find expected times for treasure hunting.
Open → 2609.11013v1

Improved upper bound found for graphs avoiding six-node cycles

An Improved Upper Bound for the Turán Number of the Hexagon

Abstract: For a graph $F$, the Turán number $\operatorname{ex}(n,F)$ is the maximum number of edges in an $n$-vertex graph containing no copy of $F$. Determining the Turán numbers of even cycles is a central problem in extremal graph theory and remains open in general. For $C_6$, the best previous upper bound was due to Füredi, Naor, and Verstraëte [Advances in Mathematics, 2006], who proved that, for sufficiently large positive integer $n$, $$ \operatorname{ex}(n,C_6) \leq λn^{4/3}+O(n)<0.6272 n^{4/3}, $$ where $λ$ is the real root of $ 16λ^3-4λ^2+λ-3=0$. We improve this bound by showing that, for sufficiently large positive integer $n$, $$ \operatorname{ex}(n,C_6) \leq αn^{4/3}+O(n)<0.6144 n^{4/3}, $$ where $α$ is the unique real root of $ 4 α^{3} (3/2)^{1-1/(2α)} =1$ in the interval $(1/2,2/3)$.

Wed 9 SeptDiscrete Mathematics
The gist
The paper deals with a problem in graph theory about how many connections a large network can have without including a specific loop of six nodes. This problem has been studied for many years. The authors improved the best known mathematical limit for how large such a network can be while still avoiding these six-node loops. Their new limit is a bit smaller than the previously known one, giving a tighter understanding of the problem.
Open → 2609.10003v1

Graph vertices that always appear in smallest identifying codes studied

On the Vertices That Belong to All Minimum Identifying Codes

Abstract: Identifying codes in graphs have been widely studied since their introduction by Karpovsky, Chakrabarty and Levitin in 1998. In this paper, we consider the vertices that are in every minimum identifying code in a graph. There are two types of such vertices: \emph{always-forced} vertices that belong to all identifying codes (minimum or not) and \emph{min-forced} vertices that belong to all minimum identifying codes. A vertex is called \emph{proper-min-forced} if it is min-forced but not always-forced. We show an upper bound $2n/3$ for the number of such proper-min-forced vertices in a closed-twin-free graph of order $n$. Moreover, for integers $n$ divisible by three, we construct an infinite family of graphs in which there are $2n/3-1$ such vertices. In addition, we determine the maximum number of edges in a graph of even order such that the graph contains proper-min-forced vertices. We also show that the decision problem of determining whether a given vertex in a graph is proper-min-forced is co-NP-hard.

Wed 9 SeptDiscrete Mathematics
The gist
Some special sets of points in networks, called identifying codes, help uniquely recognize every point by looking at nearby points. The authors study points that must appear in every smallest such set, even if they don't have to be in all bigger sets. They found limits on how many such points can exist and showed that checking if a point has this property is a hard computational problem. They also describe certain graphs that closely reach these limits.
Open → 2609.09851v1

Improved coloring limits for graphs without long induced paths

Coloring graphs with no long induced path

Abstract: Let $P_t$ denote the induced path on $t$ vertices. Let $ω(G)$ denote the maximum number of vertices in a clique of a graph $G$. Previously Gyárfás (1987) proved that every $P_t$-free graph $G$ satisfies $χ(G)\le(t-1)^{ω(G)-1}$, and Gravier, Hoàng, and Maffray (2003) improved this to $χ(G)\le (t-2)^{ω(G)-1}$ for $t\ge4$. We prove that for $t\ge5$,every $P_t$-free graph $G$ satisfies $χ(G)<c_tλ_t^{ω(G)-1}$, where $λ_t=\tfrac12\bigl(t-2+\sqrt{t(t-4)}\bigr)<t-2$ and $c_t=\sqrt{1+4/(t(t-4))}=1+O(t^{-2})$ as $t\to\infty$. The proof is based on a refinement of the Gyárfás path argument and was found by Claude Fable 5.1 of Anthropic.

Tue 8 SeptDiscrete Mathematics
The gist
This paper studies how to color certain graphs that don't have long paths inside them. Coloring a graph means assigning colors to points so that no connected points share a color. The authors improved previous upper limits on how many colors are needed depending on the size of the largest complete subgraph and the length of forbidden paths. They use a new mathematical approach to refine earlier arguments and get tighter bounds.
Open → 2609.08847v1

Spectral sparsification limits revealed for directed graphs beyond cut balance

Beyond Cut Balance: Spectral Sparsification of the Nonlinear Directed Laplacian

Abstract: Digraphs with constant cut balance admit nearly linear directed cut sparsifiers. This condition requires the total arc weights in the two directions of every cut to be within a constant factor of each other. We ask whether this condition also permits nearly linear spectral sparsification with respect to the energy of the nonlinear directed Laplacian. For a weighted digraph $G=(V,E,w)$, let \[ Q_G^+(x)=\sum_{(u,v)\in E}w_{uv}(x_u-x_v)_+^2, \qquad (t)_+:=\max\{t,0\}. \] This energy agrees with the outgoing-cut function on binary vectors. A spectral sparsifier is a nonnegatively reweighted subgraph that preserves $Q_G^+(x)$ within a factor of $1\pm\varepsilon$ simultaneously for all $x\in\mathbb R^V$. We show that cut balance alone does not yield nearly linear spectral sparsifiers: for constant error, the worst-case support size for simple unweighted Eulerian digraphs is $\widetildeΘ(n^{3/2})$, although Eulerian digraphs are perfectly cut-balanced and admit nearly linear directed cut sparsifiers. In contrast, we prove that every $n$-vertex tournament has a spectral sparsifier with $\widetilde O(n/\varepsilon^3)$ arcs, without any assumption on its cut balance. This includes the transitive tournament, whose cut balance is unbounded. Thus perfect balance does not guarantee nearly linear spectral sparsification, while unbounded imbalance does not preclude it. Finally, we use convex duality to show that preserving $Q_G^+$ also preserves, for every feasible demand vector, the optimum quadratic cost of a nonnegative flow. Hence the guarantee contains information beyond directed cut values.

Tue 8 SeptData Structures and Algorithms
The gist
The paper studies how to simplify complex directed graphs while approximately preserving certain energy measurements related to flow and direction. The authors show that even when a graph's edges are perfectly balanced between directions, it can still require a surprisingly large number of edges to accurately keep this energy. However, for a special kind of directed graph called a tournament, they prove good simplifications are possible without balance assumptions. Their results reveal unexpected limitations and possibilities in graph simplification related to direction and flow.
Open → 2609.08177v1

Delaunay triangulations guaranteed to stretch paths by less than 1.65 times

The Stretch Factor of Planar Delaunay Triangulations Is Less Than 1.65

Abstract: Delaunay triangulations are a fundamental class of plane spanners, and determining their worst-case stretch factor has been a longstanding problem in computational geometry. We prove an upper bound of 1.65, improving the previous bound of 1.998 and reducing the gap to the known lower bound of 1.5932 by a factor of more than seven. The result holds for every planar Delaunay triangulation, including configurations with collinear or cocircular sites. Our main contribution is a Bellman formulation of the disk-chain bound underlying the proof. By comparing shortest-path length with additive progress along the query segment, we obtain an exact recursion whose state records only the current disk, the incoming chord, and the difference between two prefix distances. We show that a bound for this chain class holds if and only if a potential satisfies three local inequalities for initialization, transitions, and termination. The associated Bellman value function is the pointwise smallest feasible potential, giving a precise target for constructing an upper bound. We construct such a potential using a function of one variable. Geometric monotonicity reduces its feasibility to inequalities that are affine in this function and its derivative. A spline construction, certified by exact arithmetic and rigorous interval bounds, yields the stretch bound of 1.65. We also give a dual certificate showing that every feasible quadratic profile under the same conditions requires a certified constant greater than 1.67.

Mon 7 SeptComputational Geometry
The gist
When connecting points in a plane with triangles, some connections make routes longer than the straight distance. The authors improved the known maximum factor by which these routes can stretch, proving it's less than 1.65 times the direct distance. They used a new approach involving a mathematical tool called a Bellman formulation to track progress along the route precisely. This means paths through these triangles are closer to the shortest possible than previously proven.
Open → 2609.07979v1

Improved strategies for fair and random obnoxious facility placement

Improved Randomized Approximations for Strategic Obnoxious Facility Location

Abstract: We study randomized strategyproof mechanisms for strategic obnoxious facility location on a line segment, where agents wish the facility to be located as far away from them as possible and their utility is their distance from the facility, under the social utility and minimum utility objectives. For social utility, we propose a novel randomized mechanism that breaks the previously best known \(\frac32\)-approximation of [Cheng, Yu, and Zhang, TCS 2013], achieving an approximation ratio of at most \(1.47359\). We also raise the lower bound on the approximation ratio of randomized strategyproof mechanisms from \(\frac{2}{\sqrt{3}}\approx1.15470\) [Feigenbaum et al., JAAMAS 2020] to \(\frac{105}{88}\approx1.19318\). For minimum utility, following the profile-independent approach of [Chan, Lin and Wang, AAMAS 2026], we design a simple randomized mechanism that reduces the approximation guarantee from \(\sqrt{2n}+O(1)\) to \(\sqrt n+O(1)\), where \(n\) is the number of agents. Finally, we prove that no randomized strategyproof mechanism can achieve an asymptotic approximation ratio strictly smaller than \(2\), strengthening the previous asymptotic lower bound of \(\frac32\) [Feigenbaum et al., JAAMAS 2020]. Thus, all four bounds considered in this paper strictly improve upon the corresponding previously known results.

Mon 7 SeptComputer Science and Game Theory
The gist
This paper looks at how to fairly decide where to put a facility along a line when people want it as far away from them as possible. The authors propose better random methods that improve fairness and efficiency compared to older ones. They show their methods work closer to the best possible fairness and prove limits on how good any method can be. These results help understand the best ways to balance people’s competing interests in facility placement.
Open → 2609.07261v1