Searcharxiv⌕ Search

arXiv · 2610.04440

Strictly Unfriendly $k$-Partitions: Sharp Degree Thresholds and ETH-Based Lower Bounds

Abstract

We present a complete complexity classification and fine-grained analysis for the Strictly Unfriendly $k$-Partition problem ($\text{SU}k\text{P}$), which asks whether the vertices of a graph can be partitioned into $k$ classes such that every vertex has strictly more neighbors in each of the other $k-1$ classes than in its own. We first establish a sharp tractability-intractability threshold with respect to the maximum degree $Δ$: for $k \in \{2, 3\}$, $\text{SU}k\text{P}$ is solvable in polynomial time when $Δ\le 2$, but becomes $\mathbf{NP}$-hard and ETH-hard immediately on subcubic graphs ($Δ= 3$), resolving the degree limitations in prior work and establishing subcubic graphs as the precise frontier of intractability. Furthermore, under the Exponential Time Hypothesis (ETH), we establish the first fine-grained lower bounds via direct reductions from $(3,3)$-SAT. On general graphs, we establish a uniform lower bound across all partition parameters $k \ge 2$, revealing a striking complexity convergence where the core exponential complexity remains invariant despite technical divergences in gadget constructions. On subcubic graphs, we formally quantify the "cost of sparsity," deriving explicit lower bound constants to demonstrate how enforced structural degree restrictions degrade reduction efficiency.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Sanjay Jain, Frank Stephan, Haoyun Tang. 2026-10-03. Strictly Unfriendly $k$-Partitions: Sharp Degree Thresholds and ETH-Based Lower Bounds. https://arxiv.org/abs/2610.04440

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

A Fast Algorithm for Maltsev Constraints

The constraint satisfaction problem over a set of relations $Γ$ (CSP($Γ$)) is the computational problem of deciding if a set of constraints admits at least one solution. The classical complexity for finite-domain CSP($Γ$) is settled by the CSP dichotomy theorem: it is tractable if $Γ$ satisfies a non-trivial algebraic invariant and is NP-complete otherwise. However, not all these algebraic invariants result in efficient algorithms despite being theoretically tractable. A notable case that generalizes linear equations is that of Maltsev CSPs: an $n$-variable instance with $m$ constraints is solvable in roughly $O(n^8 \cdot m)$ time by Bulatov and Dalmau (SIAM J. Comput. 2006) or $O(n^4 \cdot m)$ time by Dyer and Richerby (SIAM J. Comput. 2013). At the same time, arguably, most "natural" and efficiently usable polynomial-time algorithms rarely exceed a quadratic or cubic time bound. In this paper we revisit Maltsev constraints with this question in mind and find a $O(n^2 \cdot m)$ algorithm (for finite languages, for infinite languages we in addition need to take the total size of the instance into account). The main novel idea is to not attempt to improve the bottleneck in Bulatov and Dalmau (the Fix-Values procedure) but to avoid it altogether with a slightly more refined approach that allows us to search through a smaller space.

cs.CC↗

Reed-Solomon Codes at Capacity: Algorithmic List-Decoding and Proximity Gaps

Understanding the limits of list-decodability of Reed-Solomon codes has been one of the most important open problems in algebraic coding theory. Recently, Brakensiek, Chen, Putterman, Zhang, and Zheng, in a remarkable breakthrough, showed that Reed-Solomon (RS) codes over fields of large characteristic are algorithmically list-decodable all the way up to capacity. Building on this result, Jeronimo subsequently extended these techniques to solve the proximity-gaps question for RS codes. In this article, we give a unified and transparent exposition of these results.

cs.CC↗

An Exact Rounds-versus-Queries Trade-off for Pointer Chasing, Machine-Checked in Lean 4

A deterministic query algorithm with $d$ rounds submits $d$ batches of queries, each chosen from the answers to earlier batches. Canonne and Gur asked for general bounds on the cost of removing rounds. For $k$-step pointer chasing over $k$ tables of $m \geq 2$ entries we determine this cost exactly: for $1 \leq d \leq k$, the least worst-case number of queries with at most $d$ rounds is exactly $(k-d)m+d$, so every round removed costs exactly $m-1$ queries, which is what the naive merging of two consecutive rounds pays. The lower bound uses an adversary that answers every query with the queried index, except at the first unread cell of the chain. The model, the problem and the theorem are formalised in Lean 4 without Mathlib, with no sorry and only the axioms propext and Quot.sound; an exhaustive search confirms the formula for small parameters.

cs.CC↗