arXiv subjects

Meirav Zehavi

Publications and source records attributed to Meirav Zehavi.

At least 19 recordsLinked to original sources

arXiv2026

Fine-Grained Bounds for Courcelle's Theorem

Courcelle's theorem states that there exists an algorithm that takes as input a graph $G$ of treewidth at most $t$ and a MSO formula $\phi$, and determines whether $G$ satisfies $\phi$ in time $f(\phi,t) \cdot n$. It is folklore that the the function $f$ contains a tower of exponentials whose height depends as a linear function of the number of quantifier alternations of the input formula $\phi$. A classic reduction of Frick and Grohe shows that, assuming the Exponential Time Hypothesis (ETH), the linear growth of the height of the tower is unavoidable. Nevertheless, there is still a huge gap between existing upper and lower bounds -- after all, there is quite a difference between a single exponential and a double exponential running time. In addition, this only gives us a very coarse understanding in the time complexity of Courcelle's theorem. In this paper, we prove a fine-grained version of Courcelle's theorem with nearly ETH-tight dependence on the treewidth parameter $t$ and the quantifier structure of $\phi$ (specifically, the number of first order and second order variables in each quantifier alternation block).

cs.DS↗

arXiv2026

A Polynomial Kernel for Deletion to the Scattered Class of Cliques and Trees

The class of graph deletion problems has been extensively studied in theoretical computer science, particularly in the field of parameterized complexity. Recently, a new notion of graph deletion problems was introduced, called deletion to scattered graph classes, where after deletion, each connected component of the graph should belong to at least one of the given graph classes. While fixed-parameter algorithms were given for a wide variety of problems, little progress has been made on the kernelization complexity of any of them. In this paper, we present the first non-trivial polynomial kernel for one such deletion problem, where, after deletion, each connected component should be a clique or a tree - that is, as densest as possible or as sparsest as possible (while being connected). We develop a kernel consisting of O(k^5) vertices for this problem.

cs.DS↗

arXiv2026

Treewidth Parameterized by Feedback Vertex Number

We provide the first algorithm for computing an optimal tree decomposition for a given graph $G$ that runs in single exponential time in the feedback vertex number of $G$, that is, in time $2^{O(\text{fvn}(G))}\cdot n^{O(1)}$, where $\text{fvn}(G)$ is the feedback vertex number of $G$ and $n$ is the number of vertices of $G$. On a classification level, this improves the previously known results by Chapelle et al. [Discrete Applied Mathematics '17] and Fomin et al. [Algorithmica '18], who independently showed that an optimal tree decomposition can be computed in single exponential time in the vertex cover number of $G$. One of the biggest open problems in the area of parameterized complexity is whether we can compute an optimal tree decomposition in single exponential time in the treewidth of the input graph. The currently best known algorithm by Korhonen and Lokshtanov [STOC '23] runs in $2^{O(\text{tw}(G)^2)}\cdot n^4$ time, where $\text{tw}(G)$ is the treewidth of $G$. Our algorithm improves upon this result on graphs $G$ where $\text{fvn}(G)\in o(\text{tw}(G)^2)$. On a different note, since $\text{fvn}(G)$ is an upper bound on $\text{tw}(G)$, our algorithm can also be seen either as an important step towards a positive resolution of the above-mentioned open problem, or, if its answer is negative, then a mark of the tractability border of single exponential time algorithms for the computation of treewidth.

cs.DS↗

arXiv2026

Minimum Temporal Spanners in Happy Graphs

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

cs.DS↗

arXiv2026

Near-Linear and Parameterized Approximations for Maximum Cliques in Disk Graphs

A \emph{disk graph} is the intersection graph of (closed) disks in the plane. We consider the classic problem of finding a maximum clique in a disk graph. For general disk graphs, the complexity of this problem is still open, but for unit disk graphs, it is well known to be in P. The currently fastest algorithm runs in time $O(n^{7/3+ o(1)})$, where $n$ denotes the number of disks~\cite{EspenantKM23, keil_et_al:LIPIcs.SoCG.2025.63}. Moreover, for the case of disk graphs with $t$ distinct radii, the problem has also recently been shown to be in XP. More specifically, it is solvable in time $O^*(n^{2t})$~\cite{keil_et_al:LIPIcs.SoCG.2025.63}. In this paper, we present algorithms with improved running times by allowing for approximate solutions and by using randomization: - for unit disk graphs, we give an algorithm that, with constant success probability, computes a $(1-\varepsilon)$-approximate maximum clique in expected time $\tilde{O}(n/\varepsilon^2)$; and - for disk graphs with $t$ distinct radii, we give a parameterized approximation scheme that, with a constant success probability, computes a $(1-\varepsilon)$-approximate maximum clique in expected time $\tilde{O}(f(t)\cdot (1/\varepsilon)^{O(t)} \cdot n)$, for some (exponential) function $f(t)$.

cs.CG↗

arXiv2026

Maximum Partial List H-Coloring on P_5-free graphs in polynomial time

In this article we show that Maximum Partial List H-Coloring is polynomial-time solvable on P_5-free graphs for every fixed graph H. In particular, this implies that Maximum k-Colorable Subgraph is polynomial-time solvable on P_5-free graphs. This answers an open question from Agrawal, Lima, Lokshtanov, Saurabh & Sharma [SODA 2024]. This also improves the $n^{O(ω(G))}$-time algorithm for Maximum Partial H-Coloring by Chudnovsky, King, Pilipczuk, Rzążewski & Spirkl [SIDMA 2021] to polynomial-time algorithm.

cs.DS↗

arXiv2026

When agents choose bundles autonomously: guarantees beyond discrepancy

We consider the fair division of indivisible items among $n$ agents with additive non-negative normalized valuations, with the goal of obtaining high value guarantees, that is, close to the proportional share for each agent. We prove that partitions where \emph{every} part yields high value for each agent are asymptotically limited by a discrepancy barrier of $Θ(\sqrt{n})$. Guided by this, our main objective is to overcome this barrier and achieve stronger individual guarantees for each agent in polynomial time. Towards this, we are able to exhibit an exponential improvement over the discrepancy barrier. In particular, we can create partitions on-the-go such that when agents arrive sequentially (representing a previously-agreed priority order) and pick a part autonomously and rationally (i.e., one of highest value), then each is guaranteed a part of value at least $\mathsf{PROP} - \mathcal{O}{(\log n)}$. Moreover, we show even better guarantees for three restricted valuation classes such as those defined by: a common ordering on items, a bound on the multiplicity of values, and a hypergraph with a bound on the \emph{influence} of any agent. Specifically, we study instances where: (1) the agents are ``close'' to unanimity in their relative valuation of the items -- a generalization of the ordered additive setting; (2) the valuation functions do not assign the same positive value to more than $t$ items; and (3) the valuation functions respect a hypergraph, a setting introduced by Christodoulou et al. [EC'23], where agents are vertices and items are hyperedges. While the sizes of the hyperedges and neighborhoods can be arbitrary, the influence of any agent $a$, defined as the number of its neighbors who value at least one item positively that $a$ also values positively, is bounded.

cs.GT↗

arXiv2026

FPT Approximations for Connected Maximum Coverage

We revisit connectivity-constrained coverage through a unifying model, Partial Connected Red-Blue Dominating Set. Given a red-blue bipartite graph $G$ and an auxiliary connectivity graph $G_{conn}$ on red vertices, and integers $k, t$, the task is to find a $k$-sized subset of red vertices that dominates at least $t$ blue vertices, and that induces a connected subgraph in $G_{conn}$. This formulation captures connected variants of Max Coverage, Partial Dominating Set, and Partial Vertex Cover studied in prior literature. After identifying (parameterized) inapproximability results inherited from known problems, we first show that the problem is fixed-parameter tractable by $t$. Furthermore, when the bipartite graph excludes $K_{d,d}$ as a subgraph, we design (resp. efficient) parameterized approximation schemes for approximating $t$ (resp. $k$). Notably, these FPT approximations do not impose any restrictions on $G_{conn}$. Together, these results chart the boundary between hardness and FPT-approximability for connectivity-constrained coverage.

cs.DS↗

arXiv2025

Tight Parameterized (In)tractability of Layered Crossing Minimization: Subexponential Algorithms and Kernelization

The starting point of our work is a decade-old open question concerning the subexponential parameterized complexity of \textsc{2-Layer Crossing Minimization}. In this problem, the input is an $n$-vertex graph $G$ whose vertices are partitioned into two independent sets $V_1$ and $V_2$, and a non-negative integer $k$. The question is whether $G$ admits a 2-layered drawing with at most $k$ crossings, where each $V_i$ lies on a distinct line parallel to the $x$-axis, and all edges are straight lines. We resolve this open question by giving the first subexponential fixed-parameter algorithm for this problem, running in time $2^{O(\sqrt{k}\log k)} + n \cdot k^{O(1)}$. We then ask whether the subexponential phenomenon extends beyond two layers. In the general $h$-Layer Crossing Minimization problem, the vertex set is partitioned into $h$ independent sets $V_1, \ldots, V_h$, and the goal is to decide whether an $h$-layered drawing with at most $k$ crossings exists. We present a subexponential FPT algorithm for three layers with running time $2^{O(k^{2/3}\log k)} + n \cdot k^{O(1)}$ for $h = 3$ layers. In contrast, we show that for all $h \ge 5$, no algorithm with running time $2^{o(k/\log k)} \cdot n^{O(1)}$ exists unless the Exponential-Time Hypothesis fails. Finally, we address polynomial kernelization. While a polynomial kernel was already known for $h=2$, we design a new polynomial kernel for $h=3$. These kernels are essential ingredients in our subexponential algorithms. Finally, we rule out polynomial kernels for all $h \ge 4$ unless the polynomial hierarchy collapses.

cs.DS↗

arXiv2025

A Parameterized Perspective on Uniquely Restricted Matchings

Given a graph G, a matching is a subset of edges of G that do not share an endpoint. A matching M is uniquely restricted if the subgraph induced by the endpoints of the edges of M has exactly one perfect matching. Given a graph G and a positive integer \ell, Uniquely Restricted Matching asks whether G has a uniquely restricted matching of size at least \ell. In this paper, we study the parameterized complexity of Uniquely Restricted Matching under various parameters. Specifically, we show that Uniquely Restricted Matching admits a fixed-parameter tractable (FPT) algorithm on line graphs when parameterized by the solution size. We also establish that the problem is FPT when parameterized by the treewidth of the input graph. Furthermore, we show that Uniquely Restricted Matching does not admit a polynomial kernel with respect to the vertex cover number plus the size of the matching unless NP \subseteq coNP/poly.

cs.DS↗

arXiv2025

On Kernelization with Access to NP-Oracles

Kernelization is the standard framework to analyze preprocessing routines mathematically. Here, in terms of efficiency, we demand the preprocessing routine to run in time polynomial in the input size. However, today, various NP-complete problems are already solved very fast in practice; in particular, SAT-solvers and ILP-solvers have become extremely powerful and used frequently. Still, this fails to capture the wide variety of computational problems that lie at higher levels of the polynomial hierarchy. Thus, for such problems, it is natural to relax the definition of kernelization to permit the preprocessing routine to make polynomially many calls to a SAT-solver, rather than run, entirely, in polynomial time. Our conceptual contribution is the introduction of a new notion of a kernel that harnesses the power of SAT-solvers for preprocessing purposes, and which we term a P^NP-Kernel. Technically, we investigate various facets of this notion, by proving both positive and negative results, including a lower-bounds framework to reason about the negative results. Here, we consider both satisfiability and graph problems. Additionally, we present a meta-theorem for so-called "discovery problems". This work falls into a long line of research on extensions of the concept of kernelization, including lossy kernels [Lokshtanov et al., STOC '17], dynamic kernels [Alman et al., ACM TALG '20], counting kernels [Lokshtanov et al., ICTS '24], and streaming kernels [Fafianie and Kratsch, MFCS '14].

cs.CC↗

arXiv2025

Parameterized Approaches to Orthogonal Compaction

Orthogonal graph drawings are used in applications such as UML diagrams, VLSI layout, cable plans, and metro maps. We focus on drawing planar graphs and assume that we are given an \emph{orthogonal representation} that describes the desired shape, but not the exact coordinates of a drawing. Our aim is to compute an orthogonal drawing on the grid that has minimum area among all grid drawings that adhere to the given orthogonal representation. This problem is called orthogonal compaction (OC) and is known to be NP-hard, even for orthogonal representations of cycles [Evans et al., 2022]. We investigate the complexity of OC with respect to several parameters. Among others, we show that OC is fixed-parameter tractable with respect to the most natural of these parameters, namely, the number of \emph{kitty corners} of the orthogonal representation: the presence of pairs of kitty corners in an orthogonal representation makes the OC problem hard. Informally speaking, a pair of kitty corners is a pair of reflex corners of a face that point at each other. Accordingly, the number of kitty corners is the number of corners that are involved in some pair of kitty corners.

cs.CG↗

arXiv2025

A Simple Algorithm for Combinatorial n-Fold ILPs Using the Steinitz Lemma

We present an algorithm for a class of $n$-fold ILPs whose existing algorithms in literature are often either (1) based on the \textit{augmentation framework} where one starts with an arbitrary solution and then iteratively moves towards an optimal solution by solving appropriate programs; or (2) require solving a linear relaxation of the program; or (3) are based on decomposition/proximity based arguments. Combinatorial $n$-fold ILPs is a class of $n$-fold ILPs introduced and studied by Knop et al. [MP2020] that captures several other problems in a variety of domains. We present a simple and direct algorithm that solves combinatorial $n$-fold ILPs with unbounded non-negative variables via an application of the Steinitz lemma. Depending on the structure of the input ILP, we also improve upon the existing algorithms in the literature in terms of the running time, thereby showing an improvement that mirrors the one shown by Rohwedder [ICALP2025] contemporaneously and independently.

cs.DS↗

arXiv2025

What makes an Ensemble (Un) Interpretable?

Ensemble models are widely recognized in the ML community for their limited interpretability. For instance, while a single decision tree is considered interpretable, ensembles of trees (e.g., boosted trees) are often treated as black-boxes. Despite this folklore recognition, there remains a lack of rigorous mathematical understanding of what particularly makes an ensemble (un)-interpretable, including how fundamental factors like the (1) *number*, (2) *size*, and (3) *type* of base models influence its interpretability. In this work, we seek to bridge this gap by applying concepts from computational complexity theory to study the challenges of generating explanations for various ensemble configurations. Our analysis uncovers nuanced complexity patterns influenced by various factors. For example, we demonstrate that under standard complexity assumptions like P$\neq$NP, interpreting ensembles remains intractable even when base models are of constant size. Surprisingly, the complexity changes drastically with the number of base models: small ensembles of decision trees are efficiently interpretable, whereas interpreting ensembles with even a constant number of linear models remains intractable. We believe that our findings provide a more robust foundation for understanding the interpretability of ensembles, emphasizing the benefits of examining it through a computational complexity lens.

cs.LG↗

arXiv2025

Tournament Robustness via Redundancy

A knockout tournament is one of the most simple and popular forms of competition. Here, we are given a binary tournament tree where all leaves are labeled with seed position names. The players participating in the tournament are assigned to the seed positions. In each round, the two players assigned to leaves of the tournament tree with a common parent compete, and the winner is promoted to the parent. The last remaining player is the winner of the tournament. In this work, we study the problem of making knock-out tournaments robust against manipulation, where the form of manipulation we consider is changing the outcome of a game. We assume that our input is only the number of players that compete in the tournament, and the number of manipulations against which the tournament should be robust. Furthermore, we assume that there is a strongest player, that is, a player that beats any of the other players. However, the identity of this player is not part of the problem input. To ensure robustness against manipulation, we uncover an unexpected connection between the problem at hand and communication protocols that utilize a feedback channel, offering resilience against adversarial noise. We explore the trade-off between the size of the robust tournament tree and the degree of protection against manipulation. Specifically, we demonstrate that it is possible to tolerate up to a $1/3$ fraction of manipulations along each leaf-to-root path, at the cost of only a polynomial blow-up in the tournament size.

cs.DM↗

arXiv2025

Learning Small Decision Trees with Few Outliers: A Parameterized Perspective

Decision trees are a fundamental tool in machine learning for representing, classifying, and generalizing data. It is desirable to construct ``small'' decision trees, by minimizing either the \textit{size} ($s$) or the \textit{depth} $(d)$ of the \textit{decision tree} (\textsc{DT}). Recently, the parameterized complexity of \textsc{Decision Tree Learning} has attracted a lot of attention. We consider a generalization of \textsc{Decision Tree Learning} where given a \textit{classification instance} $E$ and an integer $t$, the task is to find a ``small'' \textsc{DT} that disagrees with $E$ in at most $t$ examples. We consider two problems: \textsc{DTSO} and \textsc{DTDO}, where the goal is to construct a \textsc{DT} minimizing $s$ and $d$, respectively. We first establish that both \textsc{DTSO} and \textsc{DTDO} are W[1]-hard when parameterized by $s+δ_{max}$ and $d+δ_{max}$, respectively, where $δ_{max}$ is the maximum number of features in which two differently labeled examples can differ. We complement this result by showing that these problems become \textsc{FPT} if we include the parameter $t$. We also consider the kernelization complexity of these problems and establish several positive and negative results for both \textsc{DTSO} and \textsc{DTDO}.

cs.LG↗

arXiv2025

(Almost-)Optimal FPT Algorithm and Kernel for $T$-Cycle on Planar Graphs

Research of cycles through specific vertices is a central topic in graph theory. In this context, we focus on a well-studied computational problem, \textsc{$T$-Cycle}: given an undirected $n$-vertex graph $G$ and a set of $k$ vertices $T\subseteq V(G)$ termed \textit{terminals}, the objective is to determine whether $G$ contains a simple cycle $C$ through all the terminals. Our contribution is twofold: (i) We provide a $2^{O(\sqrt{k}\log k)}\cdot n$-time fixed-parameter deterministic algorithm for \textsc{$T$-Cycle} on planar graphs; (ii) We provide a $k^{O(1)}\cdot n$-time deterministic kernelization algorithm for \textsc{$T$-Cycle} on planar graphs where the produced instance is of size $k\log^{O(1)}k$. Both of our algorithms are optimal in terms of both $k$ and $n$ up to (poly)logarithmic factors in $k$ under the ETH. In fact, our algorithms are the first subexponential-time fixed-parameter algorithm for \textsc{$T$-Cycle} on planar graphs, as well as the first polynomial kernel for \textsc{$T$-Cycle} on planar graphs. This substantially improves upon/expands the known literature on the parameterized complexity of the problem.

cs.DS↗

arXiv2025

Subexponential Parameterized Algorithms for Hitting Subgraphs

For a finite set $\mathcal{F}$ of graphs, the $\mathcal{F}$-Hitting problem aims to compute, for a given graph $G$ (taken from some graph class $\mathcal{G}$) of $n$ vertices (and $m$ edges) and a parameter $k\in\mathbb{N}$, a set $S$ of vertices in $G$ such that $|S|\leq k$ and $G-S$ does not contain any subgraph isomorphic to a graph in $\mathcal{F}$. As a generic problem, $\mathcal{F}$-Hitting subsumes many fundamental vertex-deletion problems that are well-studied in the literature. The $\mathcal{F}$-Hitting problem admits a simple branching algorithm with running time $2^{O(k)}\cdot n^{O(1)}$, while it cannot be solved in $2^{o(k)}\cdot n^{O(1)}$ time on general graphs assuming the ETH. In this paper, we establish a general framework to design subexponential parameterized algorithms for the $\mathcal{F}$-Hitting problem on a broad family of graph classes. Specifically, our framework yields algorithms that solve $\mathcal{F}$-Hitting with running time $2^{O(k^c)}\cdot n+O(m)$ for a constant $c<1$ on any graph class $\mathcal{G}$ that admits balanced separators whose size is (strongly) sublinear in the number of vertices and polynomial in the size of a maximum clique. Examples include all graph classes of polynomial expansion and many important classes of geometric intersection graphs. Our algorithms also apply to the \textit{weighted} version of $\mathcal{F}$-Hitting, where each vertex of $G$ has a weight and the goal is to compute the set $S$ with a minimum weight that satisfies the desired conditions. The core of our framework is an intricate subexponential branching algorithm that reduces an instance of $\mathcal{F}$-Hitting (on the aforementioned graph classes) to $2^{O(k^c)}$ general hitting-set instances, where the Gaifman graph of each instance has treewidth $O(k^c)$, for some constant $c<1$ depending on $\mathcal{F}$ and the graph class.

cs.DS↗