Stability in Graphs with Matroid Constraints∗

Fedor V. Fomin† Petr A. Golovach† Tuukka Korhonen† Saket Saurabh†‡

Abstract
We study the following Independent Stable Set problem. Let G be an undirected
graph and M = (V (G), I) be a matroid whose elements are the vertices of G. For an in-
teger k ≥ 1, the task is to decide whether G contains a set S ⊆ V (G) of size at least k
which is independent (stable) in G and independent in M. This problem generalizes sev-
arXiv:2404.03979v1 [cs.DS] 5 Apr 2024

eral well-studied algorithmic problems, including Rainbow Independent Set, Rainbow

Matching, and Bipartite Matching with Separation. We show that
• When the matroid M is represented by the independence oracle, then for any com-
putable function f , no algorithm can solve Independent Stable Set using f (k)·no(k)
calls to the oracle.
• On the other hand, when the graph G is of degeneracy d, then the problem is solvable
in time O((d + 1)k · n), and hence is FPT parameterized by d + k. Moreover, when
the degeneracy d is a constant (which is not a part of the input), the problem admits
a kernel polynomial in k. More precisely, we prove that for every integer d ≥ 0, the
problem admits a kernelization algorithm that in time nO(d) outputs an equivalent
framework with a graph on dk O(d) vertices. A lower bound complements this when d
is part of the input: Independent Stable Set does not admit a polynomial kernel
when parameterized by k + d unless NP ⊆ coNP /poly. This lower bound holds even
when M is a partition matroid.
• Another set of results concerns the scenario when the graph G is chordal. In this case,
our computational lower bound excludes an FPT algorithm when the input matroid
is given by its independence oracle. However, we demonstrate that Independent
Stable Set can be solved in 2O(k) · ∥M∥O(1) time when M is a linear matroid given
by its representation. In the same setting, Independent Stable Set does not have
a polynomial kernel when parameterized by k unless NP ⊆ coNP /poly.

1 Introduction
We initiate the algorithmic study of computing stable (independent) sets in frameworks. The
term framework, also known as pregeometric graph [30, 31], refers to a pair (G, M), where G is
a graph and M = (V (G), I) is a matroid on the vertex set of G. We remind the reader that
pairwise nonadjacent vertices of a graph form a stable or independent set. To avoid confusion
with independence in matroids, we consistently use the term ”stable set” throughout the paper.
Whenever we mention independence, it is in reference to independence with respect to a matroid.
We consider the following problem.
∗
The research leading to these results has received funding from the Research Council of Norway via the
project BWCA (grant no. 314528) and the European Research Council (ERC) via grant LOPPRE, reference
819416.
†
Department of Informatics, University of Bergen, Norway.
‡
The Institute of Mathematical Sciences, HBNI, Chennai, India

1
 Independent Stable Set
Input: A framework (G, M) and an integer k ≥ 0.
Task: Decide whether G has vertex set S ⊆ V (G) of size at least k that is
stable in G and independent in M.

The Independent Stable Set problem encompasses several well-studied problems related
to stable sets.
When M is a uniform matroid with every k-element subset of V (G) forming a basis, the
Independent Stable Set problem seeks to determine whether a graph G contains a stable
set of size at least k. This is the classic Stable Set problem.
For a partition matroid M whose elements are partitioned into k blocks and independent
sets containing at most one element from each block, Independent Stable Set transforms
into the rainbow-independence (or Rainbow-Stable Set) problem. To express this problem
in graph terminology, consider a graph G with a vertex set V (G) colored in k colors. A set
of vertices S is termed rainbow-independent if it is stable in G and no color occurs in S more
than once [3, 26]. This concept is also known in the literature as an independent transversal
[19, 18, 24] and an independent system of representatives [2].
Rainbow-independence generalizes the well-studied combinatorial concept of rainbow match-
ings [1, 13]. (Note that a matching in a graph is a stable set in its line graph.) It also has a
long history of algorithmic studies. In the Rainbow Matching problem, we are given a graph
G, whose edges are colored in q colors, and a positive integer k. The task is to decide whether
a matching of size at least k exists whose edges are colored in distinct colors. Itai, Rodeh, and
Tanimoto in [25] established that Rainbow Matching is NP-complete on bipartite graphs. Le
and Pfender [28] strongly enhanced this result by showing that Rainbow Matching is NP-
complete even on paths and complete graphs. Gupta et al. [21] considered the parameterized
complexity of Rainbow Matching. They gave an FPT algorithm of running time 2k · nO(1) .
They also provided a kernel with O(k 2 ∆) vertices, where ∆ is the maximum degree of a graph.
Later, in [22], the same set of authors obtained a kernel with O(k 2 ) vertices for Rainbow
Matching on general graphs.
When M is a transversal matroid, Independent Stable Set transforms into the Bipar-
tite Matching with Separation problem [32]. In this variant of the maximum matching
problem, the goal is to determine whether a bipartite graph H contains a matching of size k
with a separation constraint: the vertices on one side lie on a path (or a grid), and two adjacent
vertices on a path (or a grid) are not allowed to be matched simultaneously. This problem
corresponds to Independent Stable Set on a framework (G, M), where G is a path (or a
grid) on vertices U , and M is a transversal matroid of the bipartite graph H = (U, W, EH )
whose elements are U , and the independent subsets are sets of endpoints of matchings of H.
Manurangsi, Segal-Halevi, and Suksompong in [32] proved that Bipartite Matching with
Separation is NP-complete and provided approximation algorithms.
Stable Set is a notoriously difficult computational problem. It is well-known to be NP-
complete and W[1]-complete when parameterized by k [9]. On the other hand, Stable Set is
solvable in polynomial time on perfect graphs [20]. When it comes to parameterized algorithms
and kernelization, Stable Set is known to be FPT and to admit polynomial (in k) kernel on
classes of sparse graphs, like graphs of bounded degree or degeneracy [10]. The natural question
is which algorithmic results about the stable set problem could be extended to Independent
Stable Set.

• We commence with a lower bound on Independent Stable Set. Theorem 1 establishes

that when the matroid in a framework is represented by the independence oracle, for any
computable function f , no algorithm can solve Independent Stable Set using f (k) ·
2
 no(k) calls to the oracle. Moreover, we show that the lower bound holds for frameworks with
bipartite, chordal, claw-free graphs, and AT-free graphs for which the classical Stable
Set problem can be solved in polynomial time. While the usual bounds in parameterized
complexity are based on the assumption FPT ̸= W[1], Theorem 1 rules out the existence
of an FPT algorithm for Independent Stable Set parameterized by k unconditionally.

• In Section 4, we delve into the parameterized complexity of Independent Stable Set

when dealing with frameworks on d-degenerate graphs. The first result of this section,
Theorem 2, demonstrates that the problem is FPT when parameterized by d + k, by
providing an algorithm of running time O((d + 1)k · n). Addressing the kernelization
aspect, Theorem 4 reveals that when d is a constant, Independent Stable Set on
frameworks with graphs of degeneracy at most d, admits a kernel polynomial in k. More
precisely, we prove that for every integer d ≥ 0, the problem admits a kernelization
algorithm that in time nO(d) outputs an equivalent framework with a graph on dk O(d)
vertices. This is complemented by Theorem 5, establishing that Independent Stable
Set on frameworks with d-degenerate graphs and partition matroids lacks a polynomial
kernel when parameterized by k + d unless NP ⊆ coNP /poly.
Shifting the focus to the stronger maximum vertex degree ∆ parameterization, Theorem 3
establishes improved kernelization bounds. Specifically, Independent Stable Set ad-
mits a polynomial kernel on frameworks that outputs an equivalent framework with a
graph on at most k 2 ∆ vertices.

• When it comes to perfect graphs, there is no hope of polynomial or even parameterized

algorithms with parameter k: Rainbow-Stable Set is already known to be NP-complete
and W[1]-complete when parameterized by k on bipartite graphs by the straightforward
reduction from the dual Mulitcolored Biclique problem [9]. Also, the unconditional
lower bound from Theorem 1 holds for bipartite and chordal graphs if the input matroids
are given by the independence oracles.
Interestingly, it is still possible to design FPT algorithms for frameworks with chordal
graphs when the input matroids are given by their representations. In Theorem 6, we
show that Independent Stable Set can be solved in 2O(k) · ∥A∥O(1) time by a one-sided
error Monte Carlo algorithm with false negatives on frameworks with chordal graphs
and linear matroids given by their representations A. When it concerns kernelization,
Theorem 7 shows that Independent Stable Set on frameworks with chordal graphs
and partition matroids does not admit a polynomial kernel when parameterized by k
unless NP ⊆ coNP /poly.

2 Preliminaries
In this section, we introduce the basic notation used throughout the paper and provide some
auxiliary results.

Graphs. We use standard graph-theoretic terminology and refer to the textbook of Diestel [11]
for missing notions. We consider only finite undirected graphs. For a graph G, V (G) and E(G)
are used to denote its vertex and edge sets, respectively. Throughout the paper, we use n to
denote the number of vertices if it does not create confusion. For a graph G and a subset
X ⊆ V (G) of vertices, we write G[X] to denote the subgraph of G induced by X. We denote by
G − X the graph obtained from G by the deletion of every vertex of X (together with incident
edges). For v ∈ V (G), we use NG (v) to denote the (open) neighborhood of v, that is, the set
of vertices of G that are adjacent to v; NG [v] = NG (v) ∪ {v} is the closed neighborhood of
3
 S
S
v. For a set of vertices X, NG (X) = v∈X NG (v) \ X and NG [X] = v∈X NG [v]. We use
dG (v) = |NG (v)| to denote the degree of v; δ(G) and ∆(G) denote the minimum and maximum
degree of a vertex in G, respectively. For a nonnegative integer d, G is d-degenerate if for
every subgraph H of G, δ(H) ≤ d. Equivalently, a graph G is d-degenerate if there is an
ordering v1 , . . . , vn of the vertices of G, called elimination ordering, such that dGi (vi ) ≤ d for
every i ∈ {1, . . . , n} where Gi = G[{vi , . . . , vn }]. Given a d-degenerate graph G, the elimination
ordering can be computed in linear time [34]. The degeneracy of G is the minimum d such that
G is d-degenerate. We remind that a graph G is bipartite if its vertex set can be partitioned into
two sets V1 and V2 in such a way that each edge has one endpoint in V1 and one endpoint in V2 .
A graph G is chordal if it has no induced cycles on at least four vertices. A graph G is said to
be claw-free if it does not contain the claw graph K1,3 as an induced subgraph. An independent
set of three vertices such that each pair can be joined by a path avoiding the neighborhood of
the third is called an asteroidal triple (AT). A graph is AT-free if it does not contain asteroidal
triples.

Matroids. We refer to the textbook of Oxley [36] for the introduction to Matroid Theory.
Here we only briefly introduce the most important notions.
Definition 1. A pair M = (V, I), where V is a ground set and I is a family of subsets, called
independent sets of M, is a matroid if it satisfies the following conditions, called independence
axioms:
(I1) ∅ ∈ I,

(I2) if X ⊆ Y and Y ∈ I then X ∈ I,

(I3) if X, Y ∈ I and |X| < |Y |, then there is v ∈ Y \ X such that X ∪ {v} ∈ I.

We use V (M) and I(M) to denote the ground set and the family of independent sets of
M, respectively, unless M is clear from the context. An inclusion-maximal set of I is called a
base; it is well-known that all bases of M have the same cardinality. A function r : 2V → Z≥0
such that for every X ⊆ V ,

r(X) = max{|Y | : Y ⊆ X and Y ∈ I}

is called the rank function of M. The rank of M, denoted r(M), is r(V ); equivalently, the
rank of M is the size of any base of M. Let us remind that a set X ⊆ V is independent if and
only if r(X) = |X|. The closure of a set X is the set cl(X) = {v ∈ V : r(X ∪ {v}) = r(X)}.
The matroid M′ = (V \ X, I ′ ), where I ′ = {Y ∈ I : Y ⊆ V \ X}, is said to be obtained from
M by the deletion of X. The restriction of M to X ⊆ V is the matroid obtained from M by
the deletion of V \ X. If X is an independent set then the matroid M′′ = (V \ X, I ′′ ), where
I ′′ = {Y ⊆ V \ X : Y ∪ X ∈ I}, is the contraction of M by X. For a positive integer k, the
k-truncation of M = (V, I) is the matroid M′ with the same ground set V such that X ⊆ V is
independent in M′ if and only if X ∈ I and |X| ≤ k. Because in Independent Stable Set,
we are interested only in independent sets of size at most k, we assume throughout our paper
that the rank of the input matroids is upper bounded by k. Otherwise, we replace M by its
k-truncation.
In our paper, we assume in the majority of our algorithmic results that the input matroids
in instances of Independent Stable Set are given by independence oracles. An independence
oracle for M takes as its input a set X ⊆ V and correctly returns either yes or no in unit time
depending on whether X is independent or not. We assume that the memory used to store ora-
cles does not contribute to the input size; this is important for our kernelization results. Notice
that given an independence oracle, we can greedily construct an inclusion-maximal independent
4
subset of X and this can be done in O(|X|) time. Note also that the oracle for M can be
trivially transformed to an oracle for the k-truncation of M.
Our computational lower bounds, except the unconditional bound in Theorem 1, are es-
tablished for partition matroids. The partition matroid for a given partition {V1 , . . . , Vℓ } of
V is the matroid with the ground set V such that a set X ⊆ V is independent if and only if
|X ∩ Vi | ≤ 1 for each i ∈ {1, . . . , ℓ} (in a more general setting, it is required that |V ∩ Xi | ≤ di
where d1 , . . . , dℓ are some constant but we only consider the case d1 = · · · = dℓ = 1).
Matroids also could be given by their representations. Let M = (V, I) be a matroid and
let F be a field. An r × n-matrix A is a representation of M over F if there is a bijective
correspondence f between V and the set of columns of A such that for every X ⊆ V , X ∈ I if
and only if the set of columns f (X) consists of linearly independent vectors of Fr . Equivalently,
A is a representation of M if M is isomorphic to the column matroid of A, that is, the matroid
whose ground set is the set of columns of the matrix and the independence of a set of columns is
defined as the linear independence. If M has a such a representation, then M is representable
over F and it is also said M is a linear (or F-linear ) matroid.

Parameterized Complexity. We refer to the books of Cygan et al. [9] and Fomin et al. [15]
for an introduction to the area. Here we only briefly mention the notions that are most important
to state our results. A parameterized problem is a language L ⊆ Σ∗ × N where Σ∗ is a set of
strings over a finite alphabet Σ. An input of a parameterized problem is a pair (x, k) where
x is a string over Σ and k ∈ N is a parameter. A parameterized problem is fixed-parameter
tractable (or FPT) if it can be solved in time f (k) · |x|O(1) for some computable function f .
The complexity class FPT contains all fixed-parameter tractable parameterized problems. A
kernelization algorithm or kernel for a parameterized problem L is a polynomial-time algorithm
that takes as its input an instance (x, k) of L and returns an instance (x′ , k ′ ) of the same problem
such that (i) (x, k) ∈ L if and only if (x′ , k ′ ) ∈ L and (ii) |x′ | + k ′ ≤ f (k) for some computable
function f : N → N. The function f is the size of the kernel; a kernel is polynomial if f is a
polynomial. While every decidable parameterized problem is FPT if and only if the problem
admits a kernel, it is unlikely that all FPT problems have polynomial kernels. In particular,
the cross-composition technique proposed by Bodlaender, Jansen, and Kratsch [5] could be
used to prove that a certain parameterized problem does not admit a polynomial kernel unless
NP ⊆ coNP /poly.
We conclude the section by defining Rainbow-Stable Set.
Rainbow-Stable Set
Input: A graph G and a partition {V1 , . . . , Vk } of V (G) into k sets, called color
classes.
Task: Decide whether G has a stable set S of size k such that |S ∩ Vi | = 1 for
each i ∈ {1, . . . , k}.

As mentioned, Rainbow-Stable Set is a special case of Independent Stable Set for

partition matroids where k is the number of subsets in the partition defining the input matroid.

3 Unconditional computational lower bound

Because Independent Stable Set generalizes the classical Stable Set problem, Indepen-
dent Stable Set is NP-complete [16] and W[1]-complete [12]. However, when the input
matroids are given by their independence oracles, we obtain an unconditional computational
lower bound. Moreover, we show that the lower bound holds for several graph classes for which
the classical Stable Set problem can be solved in polynomial time. For this, we remind that
5
Stable Set is polynomial on claw-free and AT-free graphs by the results of Minty [35] and
Broersma et al. [8], respectively.

Theorem 1. There is no algorithm solving Independent Stable Set for frameworks with
matroids represented by the independence oracles using f (k)·no(k) oracle calls for any computable
function f . Furthermore, the bound holds for bipartite, chordal, claw-free, and AT-free graphs.

Proof. First, we show the bound for claw-free and AT-free and then explain how to modify the
proof for other graph classes.
Let p and q be positive integers. We define the graph Gp,q as the disjoint union of Gi
constructed as follows for each i ∈ {1, . . . , p}.

• For each j ∈ {1, . . . , q}, construct two vertices ai,j and bi,j ; set Ai = {ai,1 , . . . , ai,q } and
Bi = {bi,1 , . . . , bi,q }.

• Make Ai and Bi cliques.

• For each j ∈ {1, . . . , q} and for all distinct h, j ∈ {1, . . . , q}, make ai,h and bi,j adjacent.

Equivalently, each Gi is obtained by deleting a perfect matching from the complete graph K2q .
By the construction, Gp,q is both claw-free and S AT-free and has 2pq vertices. Consider a family
of indices j1 , . . . , jp ∈ {1, . . . , q} and set W = pi=1 {ai,ji , bi,ji }. We define the matroid MW with
the ground set V (Gp,q ) as follows for k = 2p:

• Each set X ⊆ V (Gp,q ) of size at most k − 1 is independent and any set of size at least
k + 1 is not independent.

• A set X ⊆ V (Gp,q ) of size k is independent if and only if either X = W or there is

i ∈ {1, . . . , p} such that |Ai ∩ X| ≥ 2 or |Bi ∩ X| ≥ 2 or there are distinct h, j ∈ {1, . . . , q}
such that ai,h , bi,j ∈ X.

Denote by IW the constructed family of independent sets. We will now show that MW is indeed
a matroid.
Claim 1.1. MW = (V (Gp,q ), IW ) is a matroid.

Proof of Claim 1.1. We have to verify that IW satisfies the independence axioms (I1)–(I3).
The axioms (I1) and (I2) for IW follow directly from the definition of IW . To establish (I3),
consider arbitrary X, Y ∈ IW such that |X| < |Y |. If |X| < k − 1 then for any v ∈ Y \ X,
Z = X ∪ {v} ∈ IW because |Z| ≤ k − 1.
Suppose |X| = k−1 and |Y | = k. If there is i ∈ {1, . . . , p} such that |Ai ∩X| ≥ 2 or |Bi ∩X| ≥
2 or there are distinct h, j ∈ {1, . . . , q} such that ai,h , bi,j ∈ X then for any v ∈ Y \ X, the set
Z = X ∪{v} has the same property and, therefore, Z ∈ IW . Assume that this is not the case. By
the construction of Gp,q , we have that for each i ∈ {1, . . . , p}, |X ∩Ai | ≤ 1 and |X ∩Bi | ≤ 1, and,
furthermore, there is j ∈ {1, . . . , q} such that X ∩ (Ai ∪ Bi ) ⊆ {ai,j , bi,j }. Because |X| = k − 1,
we can assume without loss of generality that there are indices h1 , . . . , hp ∈ {1, . . . , q} such
that X ∩ (ASi ∪ Bi ) = {ai,hi , bi,hi } for i ∈ {1, . . . , p − 1} and X ∩ (Ap ∪ Bp ) = {ap,hp }. Recall
that W = pi=1 {ai,ji , bi,ji } for j1 , . . . , jp ∈ {1, . . . , q}. If there is v ∈ Y \ X such that v ̸= bp,jp
then consider Z = X ∪ {v}. We have that there is i ∈ {1, . . . , p} such that |Ai ∩ Z| ≥ 2 or
|Bi ∩ Z| ≥ 2 or there are distinct h, j ∈ {1, . . . , q} such that ai,h , bi,j ∈ Z, that is, Z ∈ IW .
Now we assume that Y \ X = {bp,jp }. Then Y = W and we can take v = bp,jp . We obtain that
X ∪ {v} = Y ∈ IW . This concludes the proof.

We show the following lower bound for the number of oracle queries for frameworks (Gp,q , MW ).

6
Claim 1.2. Solving Independent Stable Set for instances (Gp,q , MW , k) with the matroids
MW defined by the independence oracle for an (unknown) stable set W of Gp,q of size k demands
at least q p − 1 oracle queries.

Proof of Claim 1.2. Notice that every stable set of X of size k contains exactly two vertices
of each Gi and, moreover, there is j ∈ {1, . . . , q} such that X ∩ V (Gi ) = {ai,j , bi,j }. Because
the only stable set of this structure that is independent with respect to MW is W , the task
of Independent Stable Set boils down to finding an unknown stable set W of Gp,q of size
k using oracle queries. Querying the oracle for sets X of size at most k − 1 or at least k + 1
does not provide any information about W . Also, querying the oracle for X of size k with the
property that there is i ∈ {1, . . . , p} such that |Ai ∩ X| ≥ 2 or |Bi ∩ X| ≥ 2 or there are distinct
h, j ∈ {1, . . . , q} such that ai,h , bi,j ∈ X also does not give any information because all these are
independent. Hence, we can assume that the oracle is queried only for sets X of size k with the
property that for each i ∈ {1, . . . , p}, there is j ∈ {1, . . . , q} such that X ∩ V (Gi ) = {ai,j , bi,j },
that, is the oracle is queried for stable sets of size k. The graph Gp,q has q p such sets. Suppose
that the oracle is queried for at most q p − 2 stable sets of size k with the answer no. Then there
are two distinct stable sets W and W ′ of size k such that the oracle was queried neither for W
nor W ′ . The previous queries do not help to distinguish between W and W ′ . Hence, at least
one more query is needed. This proves the claim.

Now, we are ready to prove the claim of the theorem. Suppose that there is an algorithm
A solving Independent Stable Set with at most f (k) · ng(k) oracle calls for computable
functions f and g such that g(k) = o(k). Without loss of generality, we assume that f and g
are monotone non-decreasing functions. Because g(k) = o(k), there is a positive integer K such
that g(k) < k/2 for all k ≥ K. Then for each k ≥ K, there is a positive integer Nk such that
for every n ≥ Nk , (f (k) · ng(k) + 1)k k/2 < nk/2 .
Consider instances (Gp,q , MW , k) for even k ≥ K where p = k/2 and q ≥ Nk /k. We have
that k = 2p and n = 2pq. Then A applied to such instances would use at most f (k) · ng(k) <
n k/2
− 1 = q p − 1 oracle queries contradicting Claim 1.2. This completes the proof for claw


k
and AT-free graphs.
Now we sketch the proof of Theorem 1 for bipartite graphs. For positive integers p and q,
we define Hp,q as the disjoint union of the graphs Hi for i ∈ {1, . . . , p} constructed as follows.

• For each j ∈ {1, . . . , q}, construct three vertices ai,j , bi,j , and ci,j ; set Ai = {ai,1 , . . . , ai,q },
Bi = {bi,1 , . . . , bi,q }, and Ci = {ci,1 , . . . , ci,q }.

• For each j ∈ {1, . . . , q}, make ai,j and bi,j adjacent to every ci,h for h ∈ {1, . . . , q} such
that h ̸= j.

Notice that Hp,q is a bipartite graph with 3pq vertices.SWe define R = pi=1 (Ai ∪ Bi ). Consider
S
a family of indices j1 , . . . , jp ∈ {1, . . . , q} and set W = pi=1 {ai,ji , bi,ji }. Note that W is a stable
set of Hp,q of size 2p. We define the matroid MW with the ground set V (Hp,q ) by setting a set
X ⊆ V (Hp,q ) to be independent if and only if

• for each i ∈ {1, . . . , p}, |Ci ∩ X| ≤ 1 and

• it holds that

– either X ∩ R = W ,
– or |X ∩ R| < 2p,
– or |X ∩ R| = 2p and there is i ∈ {1, . . . , p} such that |Ai ∩ X| ≥ 2 or |Bi ∩ X| ≥ 2 or
there are distinct h, j ∈ {1, . . . , q} such that ai,h , bi,j ∈ X.
7
We denote by IW the constructed family of independent sets and prove that MW is a matroid.
Claim 1.3. MW = (V (Hp,q ), IW ) is a matroid.

Proof of Claim 1.3. Let S = pi=1 Ci and consider M1 = (S, I1 ) where I1 is the set of all X ⊆ S
S
such that |X ∩ Ci | ≤ 1 for i ∈ {1, . . . , p}. Clearly, M1 is a partition matroid. Now consider
M2 = (R, I2 ) where I2 consists of sets X ⊆ D such that either X = W , or |X| < 2p, or
|X| = 2p and there is i ∈ {1, . . . , p} such that |Ai ∩ X| ≥ 2 or |Bi ∩ X| ≥ 2 or there are distinct
h, j ∈ {1, . . . , q} such that ai,h , bi,j ∈ X. We observe that M2 is a matroid and the proof of
this claim is identical to the proof of Claim 1.1. To complete the proof, it remains to note that
MW = M1 ∪ M2 , that is, a set X ∈ IW if and only if X = Y ∪ Z for Y ∈ I1 and Z ∈ I2 . This
implies that MW is a matroid [36].

We consider instances (Hp,q , MW , k) of Independent Stable Set with the matroid MW

defined by the independence oracle for an (unknown) W and k = 3p. By the definition of MW ,
any stable set X of Hp,q of size k that is independent with respect to MW has the property
that |X ∩ Ci | = 1 for every i ∈ {1, . . . , p}. The construction of Hp,q implies that if ci,j ∈ X ∩ Ci
then X ∩ (Ai ∪ Bi ) ⊆ {ai,j , bi,j }. Because |X| = k = 3p, we obtain S that X ∩ (Ai ∪ Bi ) =
{ai,j , bSi,j }. Then by the construction of MW , we obtain that X = pi=1 {ai,ji , bi,ji , ci,ji } where
W = pi=1 {ai,ji , bi,ji }, that is, X is uniquely defined by W . In the same way as in Claim 1.2 we
obtain that solving Independent Stable Set for instances (Hp,q , MW , k) with the matroids
MW defined by the independence oracle for an (unknown) W demands at least q p − 1 oracle
queries. Similarly to the case of claw and AT-free graphs, we conclude that the existence of
an algorithm for Independent Stable Set using f (k) · no(k) oracle calls would lead to a
contradiction. This finishes the proof for bipartite graphs.
For chordal graphs, we modify the construction of Hp,q by making each Ci a clique. Then
Hp,q becomes chordal but we can apply the same arguments to show that solving Independent
Stable Set for instances (Hp,q , MW , k) with the matroids MW defined by the independence
oracle for an (unknown) W demands at least q p −1 oracle queries. This completes the proof.

4 Independent Stable Set on sparse frameworks

In this section, we consider Independent Stable Set for graphs of bounded maximum degree
and graphs of bounded degeneracy. First, we observe that the problem is FPT when parame-
terized by the solution size and the degeneracy by giving a recursive branching algorithm.

Theorem 2. Independent Stable Set can be solved in O((d + 1)k · n) time on frameworks
with d-degenerate input graphs.

Proof. The algorithm is based on the following observation. Let (G, M) be a framework such
that for every v ∈ V (G), {v} ∈ I. Then there is a stable set X of G that is independent
with respect to M whose size is maximum such that X ∩ NG [v] ̸= ∅. To see this, let X be a
stable set that is also independent in M and such that X ∩ NG [v] = ∅. Because {v} and X are
independent, there is Y ⊆ X of size |X| − 1 such that Z = Y ∪ {v} is independent. Because
NG (v) ∩ Z = ∅ and Y is a stable set, Z is a stable set. Thus, set Z of size |X| is stable in G
and is independent in M. This proves the observation.
Consider an instance (G, M, k) of Independent Stable Set. Because G is a d-degenerate
graph, there is an elimination ordering v1 , . . . , vn of the vertices of G, that is, dGi (vi ) ≤ d for
every i ∈ {1, . . . , n} where Gi = G[{vi , . . . , vn }]. Recall that such an ordering can be computed
in linear time [34].
If there is v ∈ V (G) such that {v} ∈ / I, then we delete v from the framework as such vertices
are trivially irrelevant. From now on, we assume that {v} ∈ I for any v ∈ V (G). If k = 0, then
8
∅ is a solution, and we return yes and stop. If k ≥ 1 but V (G) = ∅, then we conclude that the
answer is no and stop. We can assume that V (G) ̸= ∅ and k ≥ 1.
Let u be the first vertex in the elimination ordering. Clearly, dG (u) ≤ d. We branch on at
most d + 1 instances (G − v, M/v, k − 1) for v ∈ NG [u], where M/v is the contraction of M by
{v}. By our observation, (G, M, k) is a yes-instance of Independent Stable Set if and only
if at least one of the instances (G − v, M/v, k − 1) is a yes-instance.
In each step, we have at most d + 1 branches and the depth of the search tree is at most
k. Note that we do not need to recompute the elimination ordering when a vertex is deleted;
instead, we just delete the vertex from the already constructed ordering. This means we can
use the ordering constructed for the original input instance. Thus, the total running time is
O((d + 1)k · n). This concludes the proof.

For bounded degree graphs, we prove that Independent Stable Set has a polynomial
kernel when parameterized by k and the maximum degree.

Theorem 3. Independent Stable Set admits a polynomial kernel on frameworks with graphs
of maximum degree at most ∆ such that the output instance contains a graph with at most k 2 ∆
vertices.

Proof. Let (G, M, k) be an instance of Independent Stable Set with ∆(G) ≤ ∆. Recall
that by our assumption, r(M) ≤ k. If r(M) < k then (G, M, k) is a no-instance. In this case,
our kernelization algorithm returns a trivial no-instance of constant size and stops. Now we
can assume that r(M) = k. If k = 0 then we return a trivial yes-instance as ∅ is a solution.
If ∆ = 0, then any base of M is a solution, and we return a trivial yes-instance. Now we can
assume that k ≥ 1 and ∆ ≥ 1.
We set W0 = ∅. Then for i S = 1, . . . ,
ℓ where ℓ = k∆, we greedily select a maximum-size
i−1
independent set Wi ⊆ V (G) \ j=0 Wj . Our kernelization algorithms returns the instance
ℓ
(G , M , k) where G = G[ i=1 Wi ] and M′ is the restriction of M to V (G′ ). It is straightforward
′ ′ ′
S
to see that |V (G′ )| ≤ k 2 ∆ as |Wi | ≤ r(M) = k and the new instance can be constructed in
polynomial time. We claim that (G, M, k) is a yes-instance of Independent Stable Set if
and only if (G′ , M′ , k) is a yes-instance.
Because G′ is an induced subgraph of G, any stable set of G′ is a stable set of G. This
immediately implies that if (G′ , M′ , k) is a yes-instance then any solution to (G′ , M′ , k) is a
solution to (G, M, k) and, thus, (G, M, k) is a yes-instance. Suppose that (G, M, k) is a yes-
instance. It means that G contains a stable set of size k independent in M. We show that there
is a stable set X ⊆ V (G′ ) of G of size k that is independent with respect to M.
To show this, let X be a stable set of size k that is independent in M with the maximum
number of vertices in V (G′ ). For the sake of contradiction, assume that there is u ∈ X \ V (G′ ).
We define Y = X \ {u}. Consider the set Wi for some i ∈ {1, . . . , ℓ}. By the construction of
the set, we have that u ∈ cl(Wi ). Then it holds that r(Y ∪ Wi ) ≥ r(X). This implies that
there is wi ∈ Wi such that r(Y ∪ {wi }) = r(X) = k. Because this property holds for arbitrary
i ∈ {1, . . . , ℓ}, we obtains that there are ℓ = k∆ vertices w1 , . . . , wℓ ∈ V (G′ ) such that for any
i ∈ {1, . . . , ℓ}, r(Y ∪ {wi }) = k. Notice that wi ∈ / Y for i ∈ {1, . . . , ℓ} and |NG (Y )| ≤ (k − 1)∆.
Therefore, there is i ∈ {1, . . . , ℓ} such that wi is not adjacent to any vertex of Y . Then
Z = Y ∪ {wi } is a stable set of G. However, |Z ∩ V (G′ )| > |X ∪ V (G′ )| contradicting the choice
of X. This proves that there is a stable set X ⊆ V (G′ ) of G of size k that is independent in
M. Then X is a solution to (G′ , M′ , k), that is, (G′ , M′ , k) is a yes-instance. This concludes
the proof.

Theorem 3 is handy for kernelization with parameter k when the degeneracy of the graph
in a framework is a constant.

9
Theorem 4. For every integer d ≥ 0, Independent Stable Set admits a polynomial kernel
with running time nO(d) on frameworks with graphs of degeneracy at most d such that the output
instance contains a graph with dk O(d) vertices.

Proof. Let (G, M, k) be an instance of Independent Stable Set where the degeneracy of G
is at most d. We assume without loss of generality that r(M) = k. Otherwise, if r(M) < k,
then (G, M, k) is a no-instance, and we can return a trivial no-instance of constant size and
stops. If d = 0, then G is an edgeless graph, and any set of vertices forming a base of M is a
stable set of size k that is independent with respect to M, that is, (G, M, k) is a yes-instance.
Then we return a trivial yes-instance and stop. From now on, we assume that d ≥ 1. Also,
we assume that k ≥ 2. Otherwise, if k = 0, the empty set is a trivial solution. If k = 1 then
because r(M) = k ≥ 1, there is a vertex v such that {v} ∈ I(M) and {v} is an independent
set of size k. In both cases, we return a trivial yes-instance and stop.
Since G is a d-degenerate graph, it admits an elimination ordering v1 , . . . , vn of the vertices
of G, that is, dGi (vi ) ≤ d for every i ∈ {1, . . . , n} where Gi = G[{vi , . . . , vn }]. Recall that such
an ordering can be computed in linear time [34]. For a set of vertices X ⊆ V (G), we use F (X)
to denote the set of common neighbors of the vertices of X that occur before the vertices of X
in the elimination ordering. Note that because G is a d-degenerate graph, F (X) = ∅ if |X| > d.
For an integer i ≥ 1, fi (G) = max{|F (X)| : X ⊆ V (G) and |X| = i}. Clearly, fi (G) = 0 if
i > d.
For each h = d, . . . , 1, we apply the following reduction rule starting with h = d. Whenever
the rule deletes some vertices, we do not recompute the elimination ordering; instead, we use
the induced ordering obtained from the original one by vertex deletions.
Reduction Rule 1. Set dh = d + fh+1 (G). For each X ⊆ V (G) such that |X| = h, do the
following:

(i) set W0 = ∅,

(ii) for i = 1,
S.i−1
. . , ℓ where

ℓ = kdh , greedily select a maximum-size independent set Wi ⊆
F (X) \ j=0 Wj ,
Sℓ

(iii) delete the vertices of D = F (X) \ i=1 Wi and restrict M to V (G) \ D.

It is easy to see that the rule can be applied in nO(d) time. We show that the rule is safe,
that is, it returns an equivalent instance of the problem.
Claim 4.1. Reduction Rule 1 is safe.

Proof of Claim 4.1. Let X ⊆ V (G) be of size h. Denote by G′ the graph obtained from G by
applying steps (i)–(iii) for X and let M be the restriction of M to V (G) \ D. We prove that
(G, M, k) is a yes-instance of Independent Stable Set if and only if (G′ , M′ , k) is a yes-
instance. Clearly, this is sufficient for the proof of the claim. Since G′ is an induced subgraph of
G, any solution to (G′ , M′ , k) is a solution to (G, M, k). Thus, if (G′ , M′ , k) is a yes-instance
then the same holds for (G, M, k). Hence, it remains to show that if (G, M, k) is a yes-instance
then (G′ , M′ , k) is a yes-instance as well.
We use the following axillary observation: for every v ∈ V (G) \ X, |NG (v) ∩ F (X)| ≤ dh . To
see this, consider v ∈ V (G) \ X, and denote by L and R the sets of vertices of F (X) that are
prior and after v, respectively, in the elimination ordering. By the definition of an elimination
ordering, |NG (v) ∩ R| ≤ d. For NG (v) ∩ L, we have that NG (v) ∩ L ⊆ F (X ∪ {v}). Then
|NG (v) ∩ L| ≤ |F (X ∪ {v})| ≤ fh+1 . We conclude that |NG (v) ∩ F (X)| = |NG (v) ∩ L| + |NG (v) ∩
R| ≤ d + fh+1 = dh . This proves the observation.

10
 Suppose that G has a stable set Y of size k that is independent with respect to M. Among
all these sets, we select Y such that Y ∩ D has the minimum size. We claim that Y ∩ D = ∅.
The proof is by contradiction and is similar to the proof of Theorem 3. Assume that there is
u ∈ Y ∩ D and let Z = Y \ {u}. For each i ∈ {1, . . . , ℓ}, u ∈ cl(Wi ) by the construction of Wi .
Thus, r(Z ∪ Wi ) ≥ r(Y ) and for each i ∈ {1, . . . , ℓ}, there is wi ∈ Wi such that r(Z ∪ {wi }) =
r(Y ) = k. Therefore, there are ℓ vertices w1 , . . . , wℓ ∈ F (X) \ D such that for any i ∈ {1, . . . , ℓ},
r(Z ∪ {wi }) = k. Notice that wi ∈ / Z for all i ∈ {1, . . . , ℓ} and Y ∩ X = ∅ because u is adjacent
to every vertex of X. By the above observation, we have that |NG (Z) ∩ F (X)| ≤ (k − 1)dh .
Since ℓ = kdh > (k − 1)dh , there is i ∈ {1, . . . , ℓ} such that wi ∈ / NG (Z). Then Y ′ = Z ∪ {wi }
is a stable set of G. Because Y ′ is independent with respect to M and u ∈ / D, this leads to a
contradiction with the choice of Y . We conclude that there is a stable set Y of G of size k that
is independent with respect to M such that Y ∩ D = ∅. This means that Y is a solution to
(G′ , M′ , k), that is, (G′ , M′ , k) is a yes-instance of Independent Stable Set. This concludes
the proof.

Denote by (G′ , M′ , k) the instance of Independent Stable Set obtained after applying
Reduction Rule 1. We prove that the maximum degree of G′ is bounded.
Claim 4.2. ∆(G′ ) ≤ dk 2d+1 .

Proof of Claim 4.2. For i ∈ {1, . . . , d}, denote by Gi the graph obtained from G by applying
Reduction Rule 1 for h = d, . . . , i. Note that G′ = G1 . Because r(M) = k, for each set Wj
selected in step (ii) of Reduction Rule 1, |Wj | ≤ k. Therefore, | ℓj=1 Wj | ≤ kℓ = k 2 dh . Notice
S

that for h = d, fh+1 (G) = 0 and, therefore, dh = d. This implies that fd (G k 2 d. For i < d,
Pdd ) ≤ 2(j−i+1)
2 2
we have that fi (Gi ) ≤ k di = k (d + fi+1 (Gi+1 )). Therefore, fi (Gi ) ≤ d j=i k and, as
k ≥ 2,
d d
X X k 2(d+1) − 1
f1 (G′ ) ≤ f1 (G1 ) ≤ d k 2j = d k 2j − d = d − d ≤ dk 2d+1 − d.
k2 − 1
j=1 j=0

Therefore, each vertex v of G′ has at most dk 2d+1 − d neighbors in G′ that are prior v in
the elimination ordering. Because v has at most d neighbors that are after v in the ordering,
dG′ (v) ≤ dk 2d+1 . This concludes the proof.

Because the maximum degree of G′ is bounded, we can apply Theorem 3. Applying the
kernelization algorithm from this theorem to (G′ , M′ , k), we obtain a kernel with at most dk 2d+3
vertices. This concludes the proof of the theorem.

In Theorem 4, we proved that Independent Stable Set admits a polynomial kernel on

d-degenerate graphs when d is a fixed constant. We complement this result by showing that it
is unlikely that the problem has a polynomial kernel when parameterized by both k and d.

Theorem 5. Independent Stable Set on frameworks with d-degenerate graphs and parti-
tion matroids does not admit a polynomial kernel when parameterized by k + d unless NP ⊆
coNP /poly.

Proof. We use the fact that Rainbow-Stable Set is a special case of Independent Stable
Set and show that Rainbow-Stable Set does not admit a polynomial kernel when parame-
terized by k + d unless NP ⊆ coNP /poly where k is the number of color classes.
We use cross-composition from Rainbow-Stable Set. We say that two instances (G, {V1 , . . . , Vk })
and (G′ , {V1′ , . . . , Vk′′ }) are equivalent if |V (G)| = |V (G′ )| and k = k ′ . Consider t equivalent in-
stances (Gi , {V1i , . . . , Vki }) of Rainbow-Stable Set for i ∈ {1, . . . , t} where each graph has

11
n vertices. We assume that t = 2p for some p ≥ 1. Otherwise, we add 2⌈log t⌉ − t copies of
(G1 , {V11 , . . . , Vk1 }) to achieve the property for p = ⌈log t⌉; note that by this operation, we may
add at most t instances. Then we construct the instance (G, {V1 , . . . , Vk+p }) of Rainbow-
Stable Set as follows.

• Construct the disjoint union of copies of G1 , . . . , Gt .

• For each i ∈ {1, . . . , p},

– construct two adjacent vertices ui and vi ,

– for each j ∈ {1, . . . , t}, consider the binary encoding of j − 1 as a string s with p
symbols and make all the vertices of Gj adjacent to ui if s[i] = 0 and make them
adjacent to vi , otherwise, for i ∈ {1, . . . , p}.

• Define k + p color classes Vi = tj=1 Vij for i ∈ {1, . . . , k} and Vk+i = {ui , vi } for i ∈
S
{1, . . . , p}.

It is straightforward to see that the instance (G, {V1 , . . . , Vk+p }) of Rainbow-Stable Set
can be constructed in polynomial time. We claim that (G, {V1 , . . . , Vk+p }) is a yes-instance of
Rainbow-Stable Set if and only if there is j ∈ {1, . . . , t} such that (Gj , {V1j , . . . , Vkj }) is a
yes-instance of Rainbow-Stable Set.
Suppose that (Gj , {V1j , . . . , Vkj }) is a yes-instance for some j ∈ {1, . . . , t}. Then there is a
stable set X ⊆ V (Gj ) of size k such that |X ∩ Vij | = 1 for i ∈ {1, . . . , k}. S Let s be the string
with p symbols that is the binary encoding of j − 1. Consider the set Y ⊆ pi=1 {ui , vi } such that
for each i ∈ {1, . . . , p}, Y contains either ui or vi , and ui is in Y whenever s[i] = 1. Observe
that Z = X ∪ Y is a stable set of G and it holds that |Z ∩ Vh | = 1 for each h ∈ {1, . . . , p + k}.
This means that (G, {V1 , . . . , Vk+p }) is a yes-instance of Rainbow-Stable Set.
For the opposite direction, assume that (G, {V1 , . . . , Vk+p }) is a yes-instance of Rainbow-
Stable Set. Then there is a stableSset Z of G
of size k ′ = k + p such that |Z ∩ Vh | = 1 for each
p
h ∈ {1, . . . , p + k}. Let Y = Z ∩ i=1 {ui , vi } and X = Z \ Y . By the construction of color
classes and becauseSY is a stable set, for each i ∈ {1, . . . , p}, Y contains either ui or vi . Also,
we have that X ⊆ tj=1 V (Gj ). Consider the binary string s of length p such that s[i] = 1 if
ui ∈ Y and s[i] = 0, otherwise, for all i ∈ {1, . . . , p}. Notice that the vertices of Gj such that s
is the binary encoding of j − 1 are not adjacent to the vertices of Y and for every j ′ ∈ {1, . . . , t}
distinct from j, all the vertices of Gj ′ are adjacent to at least one vertex of Y . This implies that
X ⊆ V (Gj ). Therefore, X is a stable set of Gj of size k and |X ∩ Vij | = 1 for i ∈ {1, . . . , k},
that is, (Gj , {V1j , . . . , Vkj }) is a yes-instance of Rainbow-Stable Set.
Notice that each vertex Sp v ∈ V (Gj ) for j ∈ {1, . . . , t} is adjacent in G to at most n−1 vertices
of Gj and p vertices of i=1 {ui , vi }. Therefore, the degeneracy of G is at most n+log t. Also, we
have the number of color classes k ′ = k + p ≤ n + log t. Then because Rainbow-Stable Set is
NP-complete and (G, {V1 , . . . , Vk+p }) is a yes-instance of Rainbow-Stable Set if and only if
there is j ∈ {1, . . . , t} such that (Gj , {V1j , . . . , Vkj }) is a yes-instance of Rainbow-Stable Set,
the result of Bodlaender, Jansen, and Kratsch [5] implies that Rainbow-Stable Set does not
admit a polynomial kernel unless NP ⊆ coNP /poly when parameterized by the number of color
classes k and the degeneracy of the input graph. This concludes the proof.

5 Independent Stable Set on chordal graphs

For chordal graphs, we show that Independent Stable Set is FPT in the case of linear
matroids when parameterized by k by demonstrating a dynamic programming algorithm over
tree decompositions exploiting representative sets [30, 33, 14, 29].
12
 Let M = (V, I) be a matroid and let S be a family of subsets of V . For a positive integer
q, a subfamily Sb is q-representative for S if the following holds: for every set Y ⊆ V of size at
most q, if there is a set X ∈ S disjoint from Y with X ∪ Y ∈ I then there is X b ∈ Sb disjoint
q
b ∪ Y ∈ I. We write Sb ⊆rep S to denote that Sb ⊆ S is q-representative for S. We
from Y with X
use the results of of Fomin et al. [14] to compute representative families for linear matroids. A
family of sets S is said to be a p-family for an integer p ≥ 0 if |S| = p for every S ∈ S, and we
use ∥A∥ to denote the bit-length of the encoding of a matrix A.
Proposition 1 ([14, Theorem 3.8]). Let M = (V, I) be a linear matroid and let S
= {S1 , . . . , St }
be a p-family of independent sets. Then there exists Sb ⊆qrep S of size at most p+q
p . Furthermore,
given a representation A of M over a field F, there is a randomized Monte Carlo algorithm
p+q ω−1
computing Sb ⊆qrep S of size at most p+q in O( p+q ) + ∥A∥O(1) operations over


ω

p p tp + t q
F, where ω is the exponent of matrix multiplication.1
The following theorem is proved by the bottom-up dynamic programming over a nice tree
decomposition where representative sets are used to store partial solutions.
Theorem 6. Independent Stable Set can be solved in 2O(k) · ∥A∥O(1) time by a one-sided
error Monte Carlo algorithm with false negatives on frameworks with chordal graphs and linear
matroids given by their representations A.
Proof. The algorithm uses a standard approach and, therefore, we only sketch the main ideas.
Let (G, M, k) be an instance of Independent Stable Set where G is a chordal graph and
M is a linear matroid represented by a matrix A.
We remind that a tree decomposition of a graph G is a pair (T, X ) where T is a tree and
X = {Xi | i ∈ V (T )} is a family of subsets of V (G) such that
• t∈V (T ) Xt = V (G),
S

• for every edge e of G there is a t ∈ V (T ) such that Xt contains both endpoints of e, and

• for every v ∈ V (G), the subgraph of T induced by {t ∈ V (T ) | v ∈ Xt } is connected.

The results of Gavril [17] imply that a graph G is chordal if and only if G admits a tree decom-
position where each bag is a clique. Moreover, given a chordal graph G, a tree decomposition
with clique bags (or, equivalently, a clique tree) where T has at most n nodes can be constructed
in linear time [37, 23].
A tree decomposition T = (T, X ) of G is said to nice if T is rooted in some node r and
• Xr = ∅ and for any leaf node l ∈ V (T ), Xl = ∅,

• every t ∈ V (T ) has at most two children,

• if t has one child t′ then

– either Xt = Xt′ ∪ {v} for some v ∈ V (G) \ Xt′ and t is called an introduce node,
– or Xt = Xt′ \ {v} for some v ∈ Xt′ and t is called a forget node,

• if t has two children t1 and t2 then Xt = Xt1 = Xt2 and t is called a join node.
By the results of Kloks [27], we can turn in O(n3 ) time a tree decomposition of a chordal graph
into a nice tree decomposition where each bag is a clique and T has at most n2 nodes.
Now we apply the bottom-up dynamic programming over a nice tree decomposition using
the observation that a clique can contain at most one vertex of a stable set. For t ∈ V (T ), we
1
The currently best value is ω ≈ 2.3728596 [4].
13
 S
denote by Tt the subtree of T rooted in t and define Gt = G[ t′ ∈V (Tt ) Xt′ ]. For every t ∈ V (T ),
every subset W ⊆ Xt of size at most one (that is, either W = {v} for v ∈ Xt or W = ∅), and
every integer p such that |W | ≤ p ≤ k, we compute a p-family R[t, W, p] of subsets of V (Gt )
that is q = (k − p)-representative for the family of all stable sets S ⊆ V (Gt ) of Gt of size p
such that (i) S is independent with respect to M and (ii) S ∩ Xt = W . Notice that (G, M, k)
is a yes-instance of Independent Stable Set if and only if R[r, ∅, k] ̸= ∅ and any set in
R[r, ∅, k] ̸= ∅ is a solution to the instance. For convenience,
we assume that R[t, W, 0] = ∅ if
|W | = 1. We use Proposition 1 to ensure that |R[t, W, p]| ≤ kp .
(
{∅} if p = 0,
If t is a leaf node then Xt = ∅ and R[t, ∅, p] = by the definition of R[t, W, p].
∅ if p ≥ 1,
Let t be an introduce node with the child t′ and Xt = Xt′ ∪ {v} for some v ∈ V (G) \ Xt′ .
For every W ⊆ Xt of size at most one and every integer p such that |W | ≤ p ≤ k, we set
S = {S ∪ {v} : S ∈ R[t′ , ∅, p − 1] and S ∪ {v} ∈ I}
and use Proposition 1 to compute Sb ⊆qrep S of size at most p+q


p for q = k − p. Then we set
(
R[t′ , W, p] if v ∈ / W,
R[t, W, p] =
Sb if v ∈ W.
Next, let t be a forget node with the child t′ and Xt = Xt′ \ {v} for some v ∈ Xt′ . For every
W ⊆ Xt of size at most one and every integer p such that |W | ≤ p ≤ k, we set
S = R[t′ , ∅, p] ∪ R[t′ , {v}, p].
We use Proposition 1 to compute Sb ⊆qrep S of size at most p+q


p for q = k − p. Then we set
(
Sb if W = ∅,
R[t, W, p] = ′
R[t , W, p] if W ̸= ∅.
Finally, suppose that t is a join node with the children t1 and t2 . For every W ⊆ Xt of size
at most one and every integer p such that |W | ≤ p ≤ k, we set
p
[
S= {S ∪ S ′ : S ∈ R[t1 , W, h], S ′ ∈ R[t2 , W, p − h + |W |], and S ∪ S ′ ∈ I}.
h=0

Note that S is a p-family. We use Proposition 1 to compute Sb ⊆qrep S of size at most p+q


p for
q = k − p. Then we set R[t, W, p] = S. b
The correctness of computing the families R[t, W, p] follows from the description and the
definition of representative sets. The arguments are completely standard for the bottom-up
dynamic programming over tree decompositions and we leave the details to the reader.
To evaluate the running time, observe that for each t ∈ V (T ), every W ⊆ Xt
of size at
most one, and every integer p such that |W | ≤ p ≤ k, we have that |R(t, W, p)| ≤ kp . Because
|Xt | ≤ n for each t ∈ V (T ) and |W | ≤ 1, we obtain that for each t, we keep at most 2k (n + 1)
families of sets of size at most k. Because |V (T )| ≤ n2 , we have at most 2k n2 (n+1) sets in total.
Computing R[t, W, p] for leaves takes a constant time. For introduce,
forget, and join nodes, we
k
use Proposition 1. For an introduce node, we have that |S| ≤ p−1 , for a forget node, it holds

2
that |S| ≤ 2 kp , and for a join node, |S| ≤ kp for each t ∈ V (T ), W ⊆ Xt , and p. Thus, each



3
ω+1
p-family Sb is computed in O( kp pω + kp ) + ∥A∥O(1) ) time. This implies that R[t, W, p] is

O(1)
computed in kp · ∥A∥O(1) time. Summarizing and observing that n ≤ ∥A∥, we obtain that
the total running time is 2O(k) · ∥A∥O(1) . This concludes the proof.
14
 The algorithm in Theorem 6 is randomized because it uses the algorithm from Proposition 1
to compute representative sets. For some linear matroids, the algorithm can be derandomized
using the deterministic construction of representative sets given by Lokshtanov et al. [29]. In
particular, this can be done for linear matroids over any finite field and the field of rational
numbers.
We complement Theorem 6 by proving that it is unlikely that Independent Stable Set
admits a polynomial kernel when parameterized by k in the case of chordal graphs.
Theorem 7. Independent Stable Set on frameworks with chordal graphs and partition
matroids does not admit a polynomial kernel when parameterized by k unless NP ⊆ coNP /poly.
Proof. In the same way as in the proof of Theorem 5, we prove that Rainbow-Stable Set
does not admit a polynomial kernel when parameterized by k on chordal graphs unless NP ⊆
coNP /poly where k is the number of color classes.
We construct a cross-composition from Rainbow-Stable Set. Again, we say that two in-
stances (G, {V1 , . . . , Vk }) and (G′ , {V1′ , . . . , Vk′′ }) are equivalent if |V (G)| = |V (G′ )| and k = k ′ .
Consider t equivalent instances (Gi , {V1i , . . . , Vki }) of Rainbow-Stable Set for i ∈ {1, . . . , t}
where each graph is chordal and has n vertices. Then we construct the instance (G, {V0 , V1 , . . . , Vk })
of Rainbow-Stable Set as follows.
• Construct the disjoint union of copies of G1 , . . . , Gt .
• Construct a clique K with t vertices v1 , . . . , vt .
• For each j ∈ {1, . . . , t}, make vj adjacent to all the vertices of every Gi for i ∈ {1, . . . , t}
that is distinct from j.
• Define k + 1 color classes V0 = K and Vi = tj=1 Vij for i ∈ {1, . . . , k}.
S

It is straightforward to see that G is chordal and the instance (G, {V0 , V1 , . . . , Vk }) of Rainbow-
Stable Set can be constructed in polynomial time. We claim that (G, {V0 , V1 , . . . , Vk })
is a yes-instance of Rainbow-Stable Set if and only if there is j ∈ {1, . . . , t} such that
(Gj , {V1j , . . . , Vkj }) is a yes-instance of Rainbow-Stable Set.
Suppose that (Gj , {V1j , . . . , Vkj }) is a yes-instance for some j ∈ {1, . . . , t}. Then there is a
stable set X ⊆ V (Gj ) of size k such that |X ∩ Vij | = 1 for i ∈ {1, . . . , k}. By the construction of
G, the vertex vj ∈ K is not adjacent to any vertex of Gj . Thus, Y = X ∪ {vj } is stable set of G
such that |Y ∩ Vi | = 1 for each i ∈ {0, . . . , k}. Therefore, (G, {V0 , V1 , . . . , Vk }) is a yes-instance
of Rainbow-Stable Set.
For the opposite direction, assume that (G, {V0 , V1 , . . . , Vk }) is a yes-instance of Rainbow-
Stable Set. Then there is a stable set Y of G of size k + 1 such that |Y ∩ Vi | = 1 for each
i ∈ {0, . . . , k}. In particular, |Y ∩ V0 | = 1. Then there is j ∈ {1, . . . , t} such that vj ∈ Y .
By the construction of G, we have that X = Y \ {vj } ⊆ V (Gj ). Then |X ∩ Vij | = 1 for each
i ∈ {1, . . . , k}, that is, (Gj , {V1j , . . . , Vkj }) is a yes-instance of Rainbow-Stable Set.
Le and Pfender in [28] proved that Rainbow Matching remains NP-complete on paths.
This implies that Rainbow-Stable Set is also NP-complete on paths, and hence on chordal
graphs. Because the number of color classes is k + 1 ≤ n + 1 and Rainbow-Stable Set is
NP-complete on chordal graphs, we can apply the result of Bodlaender, Jansen, and Kratsch [5].
This concludes the proof.

6 Conclusion
In this paper, we investigated the parameterized complexity of the Independent Stable Set
problem for various classes of graphs where the classical Stable Set problem is tractable. We
15
derived kernelization results and FPT algorithms, complemented by complexity lower bounds.
We believe exploring Independent Stable Set on other natural graph classes with similar
properties would be interesting. For instance, Stable Set is solvable in polynomial time
on claw-free graphs [35] and AT-free graphs [8]. While our unconditional lower bound from
Theorem 1 applies to these classes, it does not rule out the possibility of FPT algorithms for
frameworks with linear matroids. A similar question arises regarding graphs with a polynomial
number of minimal separators [6, 7].

References
[1] R. Aharoni, E. Berger, M. Chudnovsky, D. M. Howard, and P. D. Seymour,
Large rainbow matchings in general graphs, Eur. J. Comb., 79 (2019), pp. 222–227. 2

[2] R. Aharoni, E. Berger, and R. Ziv, Independent systems of representatives in weighted

graphs, Combinatorica, 27 (2007), pp. 253–267. 2

[3] R. Aharoni, J. Briggs, J. Kim, and M. Kim, Rainbow independent sets in certain
classes of graphs, Journal of Graph Theory, 104 (2023), pp. 557–584. 2

[4] J. Alman and V. V. Williams, A refined laser method and faster matrix multiplication,
in Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021,
Virtual Conference, January 10 - 13, 2021, D. Marx, ed., SIAM, 2021, pp. 522–539. 13

[5] H. L. Bodlaender, B. M. P. Jansen, and S. Kratsch, Kernelization lower bounds

by cross-composition, SIAM J. Discret. Math., 28 (2014), pp. 277–305. 5, 12, 15

[6] V. Bouchitté and I. Todinca, Treewidth and minimum fill-in: Grouping the minimal
separators, SIAM J. Comput., 31 (2001), pp. 212–232. 16

[7] , Listing all potential maximal cliques of a graph, Theor. Comput. Sci., 276 (2002),
pp. 17–32. 16

[8] H. Broersma, T. Kloks, D. Kratsch, and H. Müller, Independent sets in asteroidal

triple-free graphs, SIAM J. Discret. Math., 12 (1999), pp. 276–287. 6, 16

[9] M. Cygan, F. V. Fomin, L. Kowalik, D. Lokshtanov, D. Marx, M. Pilipczuk,

M. Pilipczuk, and S. Saurabh, Parameterized Algorithms, Springer, 2015. 2, 3, 5

[10] M. Cygan, F. Grandoni, and D. Hermelin, Tight kernel bounds for problems on
graphs with small degeneracy, ACM Trans. Algorithms, 13 (2017), pp. 43:1–43:22. 2

[11] R. Diestel, Graph Theory, 4th Edition, vol. 173 of Graduate texts in mathematics,
Springer, 2012. 3

[12] R. G. Downey and M. R. Fellows, Fundamentals of Parameterized Complexity, Texts

in Computer Science, Springer, 2013. 5

[13] A. A. Drisko, Transversals in row-latin rectangles, Journal of Combinatorial Theory,

Series A, 84 (1998), pp. 181–195. 2

[14] F. V. Fomin, D. Lokshtanov, F. Panolan, and S. Saurabh, Efficient computation

of representative families with applications in parameterized and exact algorithms, J. ACM,
63 (2016), pp. 29:1–29:60. 12, 13

16
[15] F. V. Fomin, D. Lokshtanov, S. Saurabh, and M. Zehavi, Kernelization: theory of
parameterized preprocessing, Cambridge University Press, 2019. 5

[16] M. R. Garey and D. S. Johnson, Computers and Intractability: A Guide to the Theory
of NP-Completeness, W. H. Freeman, 1979. 5

[17] F. Gavril, The intersection graphs of subtrees in trees are exactly the chordal graphs, J.
Combinatorial Theory Ser. B, 16 (1974), pp. 47–56. 13

[18] A. Graf, D. G. Harris, and P. Haxell, Algorithms for weighted independent transver-
sals and strong colouring, ACM Trans. Algorithms, 18 (2022), pp. 1:1–1:16. 2

[19] A. Graf and P. Haxell, Finding independent transversals efficiently, Comb. Probab.
Comput., 29 (2020), pp. 780–806. 2

[20] M. Grötschel, L. Lovász, and A. Schrijver, Geometric algorithms and combinatorial

optimization, vol. 2, Springer Science & Business Media, 2012. 2

[21] S. Gupta, S. Roy, S. Saurabh, and M. Zehavi, Parameterized algorithms and kernels
for rainbow matching, Algorithmica, 81 (2019), pp. 1684–1698. 2

[22] , Quadratic vertex kernel for rainbow matching, Algorithmica, 82 (2020), pp. 881–897.
2

[23] M. Habib, R. M. McConnell, C. Paul, and L. Viennot, Lex-bfs and partition refine-
ment, with applications to transitive orientation, interval graph recognition and consecutive
ones testing, Theor. Comput. Sci., 234 (2000), pp. 59–84. 13

[24] P. Haxell, On forming committees, The American Mathematical Monthly, 118 (2011),
pp. 777–788. 2

[25] A. Itai, M. Rodeh, and S. L. Tanimoto, Some matching problems for bipartite graphs,
J. ACM, 25 (1978), pp. 517–525. 2

[26] J. Kim, M. Kim, and O.-j. Kwon, Rainbow independent sets on dense graph classes,
Discrete Applied Mathematics, 312 (2022), pp. 45–51. 2

[27] T. Kloks, Treewidth, Computations and Approximations, vol. 842 of Lecture Notes in
Computer Science, Springer, 1994. 13

[28] V. B. Le and F. Pfender, Complexity results for rainbow matchings, Theor. Comput.
Sci., 524 (2014), pp. 27–33. 2, 15

[29] D. Lokshtanov, P. Misra, F. Panolan, and S. Saurabh, Deterministic truncation

of linear matroids, ACM Trans. Algorithms, 14 (2018), pp. 14:1–14:20. 12, 15

[30] L. Lovász, Flats in matroids and geometric graphs, in Combinatorial surveys (Proc. Sixth
British Combinatorial Conf., Royal Holloway Coll., Egham, 1977), 1977, pp. 45–86. 1, 12

[31] L. Lovász, Graphs and geometry, vol. 65 of American Mathematical Society Colloquium
Publications, American Mathematical Society, Providence, RI, 2019. 1

[32] P. Manurangsi, E. Segal-Halevi, and W. Suksompong, On maximum bipartite

matching with separation, Inf. Process. Lett., 182 (2023), p. 106388. 2

[33] D. Marx, A parameterized view on matroid optimization problems, Theor. Comput. Sci.,
410 (2009), pp. 4471–4479. 12
17
[34] D. W. Matula and L. L. Beck, Smallest-last ordering and clustering and graph coloring
algorithms, J. ACM, 30 (1983), pp. 417–427. 4, 8, 10

[35] G. J. Minty, On maximal independent sets of vertices in claw-free graphs, J. Comb.

Theory, Ser. B, 28 (1980), pp. 284–304. 6, 16

[36] J. Oxley, Matroid theory, vol. 21 of Oxford Graduate Texts in Mathematics, Oxford
University Press, Oxford, second ed., 2011. 4, 8

[37] D. J. Rose, R. E. Tarjan, and G. S. Lueker, Algorithmic aspects of vertex elimination

on graphs, SIAM J. Comput., 5 (1976), pp. 266–283. 13

18