Abstract 1 Introduction 2 Preliminaries 3 Basic Observations 4 An FPT algorithm for the parameterization by rank and 𝒌 5 Partition matroids 6 Complexity dichotomy for the parameterization by rank 7 Conclusion References

Fault-Tolerant Matroid Bases

Matthias Bentert ORCID University of Bergen, Norway
Technische Universität Berlin, Germany
Fedor V. Fomin ORCID University of Bergen, Norway Petr A. Golovach ORCID University of Bergen, Norway Laure Morelle ORCID LIRMM, Univ Montpellier, CNRS, Montpellier, France
Abstract

We investigate the problem of constructing fault-tolerant bases in matroids. Given a matroid and a redundancy parameter k, a k-fault-tolerant basis is a minimum-size set of elements such that, even after the removal of any k elements, the remaining subset still spans the entire ground set. Since matroids generalize linear independence across structures such as vector spaces, graphs, and set systems, this problem unifies and extends several fault-tolerant concepts appearing in prior research.

Our main contribution is a fixed-parameter tractable (FPT) algorithm for the k-fault-tolerant basis problem, parameterized by both k and the rank r of the matroid. This two-variable parameterization by k+r is shown to be tight in the following sense. On the one hand, the problem is already NP-hard for k=1. On the other hand, it is ParaNP-hard for r3 and polynomial-time solvable for r2.

Keywords and phrases:
Parameterized Complexity, matroids, robust bases
Funding:
Matthias Bentert: Supported by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No. 819416) and ERC Consolidator grant AdjustNet (agreement No. 864228).
Fedor V. Fomin: Supported by the Research Council of Norway under BWCA project (grant no. 314528).
Petr A. Golovach: Supported by the Research Council of Norway under BWCA project (grant no. 314528).
Copyright and License:
[Uncaptioned image] © Matthias Bentert, Fedor V. Fomin, Petr A. Golovach, and Laure Morelle; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Mathematics of computing Combinatorial algorithms
; Theory of computation Fixed parameter tractability
Related Version:
Full Version: https://arxiv.org/abs/2506.22010 [4]
Funding:
The research leading to these results have been supported by the Research Council of Norway via the Franco-Norwegian AURORA project (grant no. 349476).
Editors:
Anne Benoit, Haim Kaplan, Sebastian Wild, and Grzegorz Herman

1 Introduction

A basis in a d-dimensional vector space 𝒱 is a set of exactly d linearly independent vectors {𝐯1,,𝐯d}. Any vector 𝐱𝒱 then has a unique representation 𝐱=α1𝐯1++αd𝐯d. However, if certain basis vectors are lost or corrupted – for instance, in a distributed storage system where vectors are stored across multiple servers that can malfunction – it may be challenging or impossible to accurately recover 𝐱. The algorithmic question we address in this paper is: For an expected number k of failures, what is the minimum-size k-fault-tolerant set of vectors that still guarantees data reconstructability?

A natural way to capture the notions of basis and independence is through matroids, which generalize linear independence to a variety of combinatorial settings (like graphs, set systems, vector spaces). Let =(E,) be a matroid, and let k be a nonnegative integer. We say that BE is a k-fault-tolerant basis of if B is a minimum-size set such that, for every subset FB of size at most k, we have 𝗋𝖺𝗇𝗄(BF)=𝗋𝖺𝗇𝗄(). (All necessary matroid definitions appear in the Preliminaries section.) Equivalently, this condition means that 𝖼𝗅(BF)=E, where 𝖼𝗅() denotes matroid closure. Note that this concept generalizes the standard basis definition: a 0-fault-tolerant basis is simply a basis of . However, while every matroid has a basis, it may not admit a k-fault-tolerant basis for k1. We investigate the following problem.

Fault-Tolerant Basis

Input: A matroid =(E,) and nonnegative integer k.
Task: Find a k-fault-tolerant basis BE or correctly decide that none exists.

Let us give some examples of Fault-Tolerant Basis.

Linear Matroids.

A linear matroid over a field 𝔽 can be represented by a set of vectors {𝐯1,,𝐯m} in a vector space 𝒱𝔽d. The rank of the matroid corresponds to dim(𝒱). A basis here is simply a set of d linearly independent vectors. A set of vectors {𝐮1,,𝐮r} is k-fault-tolerant if, after removing up to k vectors, the remaining set still spans the entire subspace 𝒱. Such concepts naturally arise in distributed storage – where vectors might be stored on different servers [11] – and in coding theory, where losing some symbols or vectors should not destroy the ability to recover the entire space [13].

Graphic Matroids.

For a connected graph G, its graphic matroid (G) has ground set E(G), and a set IE(G) is independent if it forms a forest. A basis is thus a spanning tree of G. In this matroid, a set of edges BE(G) is k-fault-tolerant if, upon removing any k edges, the subgraph remains connected. Thus, a k-fault-tolerant basis is a (k+1)-edge connected spanning subgraph with minimum number of edges. This problem is known in the literature as k-Edge-Connected Spanning Subgraph [8, 14, 17]. It is motivated by network applications as its task is to compute a minimum-cost sub-network that is resilient against up to k link failures (see also [5]).

Gammoids.

A gammoid is derived from a directed (or undirected) graph D. Let X and Y be two distinguished sets of vertices of V(D). Within the set X, define a subset UX to be independent if there exist |U| vertex-disjoint paths in G originating from vertices in Y and ending in the vertices of U. The basis of the gammoid is the maximum set of vertices from X that can be reached by vertex-disjoint paths from Y. In this case, a vertex set ZX is a k-fault-tolerant basis if upon removing any k vertices from Z, the remaining vertices are still linkable from sources in Y without losing rank. This problem is related to the problem of finding fault-tolerant disjoint paths studied by Adjiashvili et al. [1].

Transversal Matroids.

A transversal matroid (U,𝒮) is described via a bipartite graph between a ground set U and a set of “target positions” 𝒮. A set IU is independent if it can be matched injectively to distinct elements in 𝒮. The basis of the transversal matroid is a maximum-size subset IU that can be perfectly matched into 𝒮. Finding a k-fault-tolerant basis for a transversal matroids is naturally related to robust matching problems, where one wants to preserve a perfect (or maximum) matching under the loss of a few vertices or edges [12, 18].

1.1 Our Contribution

We investigate the parameterized complexity of Fault-Tolerant Basis under natural parameterizations by k and the rank r of the input matroid. (We refer to the textbook by Cygan et al. [10] for an introduction to parameterized complexity.) Our main result is that the problem is FPT when parameterized by both k and r.

Theorem 1.

Fault-Tolerant Basis can be solved in (kr)𝒪(kr4)n𝒪(1) time on n-element matroids of rank at most r given by independence oracles.

To prove Theorem 1, we design an algorithm that recursively decomposes the input matroid and identifies a small core set containing any possible k-fault-tolerant basis, thereby restricting the problem to a bounded search space. More precisely, the algorithm locates a set W of important elements with bounded size such that, if the input matroid admits a k-fault-tolerant basis, then there is one contained entirely in W. The construction of W is guided by the observation (see Observation 7) that if X is a rank-r set with r+k elements such that every r-element subset of X is independent, then X is already a k-fault-tolerant basis. Hence, finding such an X would immediately solve the problem. Otherwise, we identify an inclusion-maximal rank-r set X (of bounded size) such that for every r-element subset YX, the rank of Y is r. The crucial insight here is that the closure 𝖼𝗅(X) of X can be expressed as the union of 𝖼𝗅(S) over all (r1)-element subsets S of X. We then proceed recursively, selecting elements of W by searching for analogous sets in the closures of each S, applying the same approach used to choose X. Once we have computed W, we determine whether a k-fault-tolerant basis exists within W by enumerating all candidate subsets via a brute-force algorithm. If such a basis is found, it is also a valid solution for the original matroid.

We then show that the result of Theorem 1 is tight. First, by adapting the results of Fomin et al. [15] for our purposes, we observe the following lower bound.

Proposition 2.

It is W[1]-hard for the parameterization by k to decide whether a given linear matroid has a k-fault-tolerant basis.

For the parameterization of Fault-Tolerant Basis by k, we remind that Fault-Tolerant Basis for graphic matroids is equivalent to finding a (k+1)-edge connected spanning subgraph with the minimum number of edges. As was shown by Fernandes [14], an n-vertex graph G has a 2-edge connected spanning subgraph with at most n edges if and only if G has a Hamiltonian cycle. Thus, Fault-Tolerant Basis is intractable already for k=1. Taking into account the inapproximability lower bounds for higher connectivities established by Gabow et al. [17], we obtain the following observation.

Observation 3.

For every integer k1, it is NP-hard to decide whether a graphic matroid given with an integer b1 has a k-fault-tolerant basis of size at most b.

For the parameterization by the rank, we establish a dichotomy – for any fixed r3, Fault-Tolerant Basis is intractable, but for r2, the problem can be solved in polynomial time. In fact, for r2, we solve the more general weighted variant of Fault-Tolerant Basis. In Weighted Fault-Tolerant Basis, we are given a matroid together with a weight function w:E()0, and the task is to find a set BE() of minimum total weight such that for any set FB of size at most k, 𝗋𝖺𝗇𝗄(BF)=𝗋𝖺𝗇𝗄(). Our result is summarized in the following theorem.

Theorem 4.

For any integer r3, it is NP-hard to decide whether a linear matroid of rank r over rationals given together with integers k and b has a k-fault-tolerant basis of size at most b. For r2, Weighted Fault-Tolerant Basis can be solved in 𝒪(n2) on matroids given by an independence oracle.

In particular, one can find a k-fault-tolerant basis of vectors in 2 in polynomial time but the problem becomes NP-hard in 3. To obtain the hardness for r3, we use the result of Froese et al. [16] stating that, given a set P of points on the plane and a positive integer k, it is NP-hard to decide whether P contains at least k points in general position. To establish the claim for r2, it is convenient to show a more general result for partition matroids which may be of independent interest.

Proposition 5.

Given an n-element partition matroid with unit capacities together with a weight function w:E()0 and integers r,k0, one can find in 𝒪(n2) time either a set XE() of minimum weight such that, for any set FX of size at most k, it holds that 𝗋𝖺𝗇𝗄(XF)r or correctly decide that such a set does not exist.

1.2 Related Work

Adjiashvili, Stiller, and Zenklusen [2] introduced a Bulk-Robustness model of combinatorial optimization. They studied several instances of this framework, including the Bulk-Robust Minimum Matroid Basis problem, which is most relevant to our work. In this setting, for a matroid =(E,), we are given a collection of interdiction sets Ω={F1,F2,,Fm}, where FiE() for each i{1,,m}. The goal is to find a cheapest subset XE() such that XFi contains a basis of for every i{1,,m}. Adjiashvili, Stiller, and Zenklusen provided an 𝒪(logm+logr)-approximation algorithm for Bulk-Robust Minimum Matroid Basis, where r is the rank of the matroid. The problem Fault-Tolerant Basis can be viewed as a special case of Bulk-Robust Minimum Matroid Basis when Ω consists of all subsets of E of size k.

There are several prior works investigating fault-tolerance for classic optimization problems. The model of s-t-Path and s-t-Flow problems with safe and vulnerable edges was introduced by Adjiashvili et al. [1], who studied the approximability of these problems. Subsequently, generalizations were also studied [3, 7, 9]. Bentert et al. [5] studied the parameterized complexity of computing a fault-tolerant spanning tree. Approximation algorithms and inapproximability lower bounds for k-Edge-Connected Spanning Subgraph have been considered in [8, 14, 17, 19].

More generally, Fault-Tolerant Basis belongs to robust optimization, a branch of optimization that adapts classic optimization-theoretic tools to settings with uncertainty. For a comprehensive introduction, see the survey by Bertsimas et al. [6].

2 Preliminaries

We refer to the book of Oxley [21] for a detailed introduction to matroids. A pair =(E,), where E is a finite ground set and is a family of subsets of the ground set, called independent sets of , is a matroid if it satisfies the following conditions, called independence axioms:

  1. (I1)

    .

  2. (I2)

    If ABE and B then A.

  3. (I3)

    If A,B and |A|<|B|, then there is eBA such that A{e}.

We use E() and () to denote the ground set and the set of independent sets, respectively. An inclusion-maximal independent set B is called a basis of . We use () to denote the set of bases of . All the bases of have the same size called the rank of and denoted by 𝗋𝖺𝗇𝗄(). The rank of a subset AE(), denoted by 𝗋𝖺𝗇𝗄(A), is the maximum size of an independent set XA; the function 𝗋𝖺𝗇𝗄:2E() is the rank function of M. A set AE() spans an element xE() if 𝗋𝖺𝗇𝗄(A{x})=𝗋𝖺𝗇𝗄(A). The closure (or span) of A is the set 𝖼𝗅(A)={xE(M)A spans x}. Closures satisfy the following properties, called closure axioms:

  1. (CL1)

    For every AE(), A𝖼𝗅(A).

  2. (CL2)

    If ABE(), then 𝖼𝗅(A)𝖼𝗅(B).

  3. (CL3)

    For every AE(), 𝖼𝗅(A)=𝖼𝗅(𝖼𝗅(A)).

  4. (CL4)

    For every AE(), every xE()A, and every y𝖼𝗅(A{x})𝖼𝗅(A), x𝖼𝗅(A{y}).

For SE(M), the matroid obtained by deleting S, denoted by =S, is the matroid such that E()=E()S and ()={X()SX=}. Let r0 be an integer. The r-truncation of a matroid is the matroid with E()=E() such that X() if and only if X() and |X|r. A matroid is a partition matroid if there is a partition (P1,,Pd) of the ground set and a d-tuple (c1,,cd) of positive integers, called capacities, such that a set XE(G) is independent if and only if |XPi|ci for every i{1,,d}. A d×n-matrix 𝐀 over a field 𝔽 is a representation of a matroid over 𝔽 if there is a one-to-one correspondence f between E() and the columns of 𝐀 such that for any XE(), it holds that X() if and only if the columns in {f(x)xX} are linearly independent (as vectors of 𝔽d). If has such a representation, then has a representation over 𝔽. A matroid admitting a representation over 𝔽 is said to be linear; a matroid is binary if it has a representation over 𝖦𝖥[2].

In our algorithms for general matroids, we assume that input matroids are given by independence oracles. Such an oracle for a matroid , takes as input a set XE() and correctly answers in a constant time whether X(). We note that some matroids could be given explicitly, for example, by their representations.

3 Basic Observations

In this section, we prove a couple of simple results that will be helpful in the later discussion. Recall that for an integer k0, BE(M) is a k-fault-tolerant basis of a matroid if B is a subset of minimum cardinality such that 𝗋𝖺𝗇𝗄(BF)=𝗋𝖺𝗇𝗄() for every subset FB of size at most k. We use the following bounds on the size of a k-fault-tolerant basis.

Proposition 6.

Let be a matroid with 𝗋𝖺𝗇𝗄()1 and let k0 be an integer. Then for a k-fault-tolerant basis B of , it holds that

𝗋𝖺𝗇𝗄()+k|B|(k+1)𝗋𝖺𝗇𝗄().

Proof.

The lower bound immediately follows from the definition of a k-fault-tolerant basis. To show the upper bound, assume for the sake of contradiction that |B|>(k+1)𝗋𝖺𝗇𝗄(). We iteratively construct sets X0,,Xk where X0B is an inclusion-maximal independent set in B, and for each i{1,,k}, Xi is an inclusion-maximal independent set in B(j=0i1Xj). Since 𝗋𝖺𝗇𝗄(B)=𝗋𝖺𝗇𝗄() and |B|>(k+1)𝗋𝖺𝗇𝗄(), such sets X0,,Xk exist. Set B=i=0kXi. Consider an arbitrary FB of size at most k. By the pigeonhole principle, there is an index i{0,,k} such that XiF=. By construction, it holds that BBB(j=0i1Xj)𝖼𝗅(Xi). Hence, BF(BF)(BB)𝖼𝗅(BF). Because B is a k-fault-tolerant basis, 𝖼𝗅(BF)=E(). Thus,

E()=𝖼𝗅(BF)𝖼𝗅(𝖼𝗅(BF))=𝖼𝗅(BF).

Since F was chosen arbitrarily, we obtain that B is a k-fault-tolerant basis of . However, since |B|<|B|, this contradicts the choice of B.

We next argue that the bounds in Proposition 6 are tight. First, note that the lower bound is tight as the matroid ()={XE():|X|k} proves. We next argue that the upper bound is also tight. Let e1,,er be a basis of r. Let k and n be integers such that 0k<n. Consider the linear matroid with E()={jei1ir and 1jn}. It is easy to see that any k-fault-tolerant basis of has to contain at least k+1 vectors of {jei1jn} for each i{1,,r}. Thus, the size of a k-fault-tolerant basis is at least (k+1)r. From the other side, we have that, for B={jei1ir and 1jk+1}, 𝗋𝖺𝗇𝗄(BF)=r for any FE() of size at most k. Thus, B is a k-fault-tolerant basis of size (k+1)r of .

Let be a matroid. For a positive integer h, we say that a set XE() is h-uniform if 𝗋𝖺𝗇𝗄(X)=h and 𝗋𝖺𝗇𝗄(Y)=h for every subset YX of size h. The definition and Proposition 6 yield the following.

Observation 7.

Let be a matroid of rank r1, k0 be an integer, and BE() be a set of size k+r. Then, B is a k-fault-tolerant basis of if and only if B is r-uniform.

Proof.

If B is a k-fault-tolerant basis, then, for every set FB of size at most k, 𝗋𝖺𝗇𝗄(BF)=r. Since |B|=k+r, this implies that, for every set XB of size r, 𝗋𝖺𝗇𝗄(X)=𝗋𝖺𝗇𝗄(B)=r, that is, B is r-uniform. For the opposite direction, if B is r-uniform, then, for any XB of size r, 𝗋𝖺𝗇𝗄(X)=𝗋𝖺𝗇𝗄(B)=𝗋𝖺𝗇𝗄(). Since |B|=k+r, it holds for any FB of size at most k that 𝗋𝖺𝗇𝗄(BF)=𝗋𝖺𝗇𝗄(). This completes the proof.

We conclude this section by proving Proposition 2 using the results of Fomin et al. [15]. In particular, they studied Rank h-Reduction. Here, the input is a binary matroid given by its representation over 𝖦𝖥[2] and two positive integers h and k. The task is to decide whether there is a set XE() of size at most k such that 𝗋𝖺𝗇𝗄()𝗋𝖺𝗇𝗄(X)h.

Proposition 2. [Restated, see original statement.]

It is W[1]-hard for the parameterization by k to decide whether a given linear matroid has a k-fault-tolerant basis.

Proof.

We reduce from Rank h-Reduction parameterized by k, which is known to be W[1]-hard [15]. Let (,h,k) be an instance of Rank h-Reduction where is a binary matroid of rank r. We define to be the (rh+1)-truncation of . Notice that is a linear matroid and its representation (over a different field) can be constructed in polynomial time by the result of Lokshtanov et al. [20]. We claim that has no k-fault-tolerant basis if and only if (,h,k) is a yes-instance of Rank h-Reduction.

To this end, note that has no k-fault-tolerant basis if and only if there is a set XE() of size at most k such that 𝗋𝖺𝗇𝗄(X)<𝗋𝖺𝗇𝗄()=𝗋𝖺𝗇𝗄()h+1. Since 𝗋𝖺𝗇𝗄(X)<𝗋𝖺𝗇𝗄()h+1 if and only if 𝗋𝖺𝗇𝗄()𝗋𝖺𝗇𝗄(X)h, has no k-fault-tolerant basis if and only if there is XE() of size at most k such that 𝗋𝖺𝗇𝗄()𝗋𝖺𝗇𝗄(X)h. This concludes the proof.

We remark that since the hardness for Rank h-Reduction was proven by Fomin et al. [15] via a polynomial-time reduction from Clique, it is coNP-hard to decide whether a linear matroid has a k-fault-tolerant basis. We also note that the problem is in XP since we can decide in n𝒪(k) time whether an n-element matroid has a k-fault-tolerant basis – simply check for each subset XE() of size k whether 𝗋𝖺𝗇𝗄(X)=𝗋𝖺𝗇𝗄().

4 An FPT algorithm for the parameterization by rank and 𝒌

In this section, we prove Theorem 1. We construct a recursive branching algorithm that finds a set W of important elements of bounded size with the property that, if the input matroid has a k-fault-tolerant basis, then there is a k-fault-tolerant basis BW. Note that a k-fault-tolerant basis has minimum size by definition. Then, we select a k-fault-tolerant basis (if it exists) in W using brute force. The construction of W is inspired by Observation 7, which indicates that h-uniform sets are preferable in the construction of k-fault-tolerant bases. The following lemma is crucial for constructing W.

Lemma 8.

Let be a matroid of rank r1 and k0 be an integer. Let XE() be an h-uniform set of size at least (h1)[(k+1)r]r1+(k+1)r for some 1hr. Then, for any k-fault-tolerant basis B of , there is a k-fault-tolerant basis B such that

  1. (i)

    B𝖼𝗅(X)=B𝖼𝗅(X) and

  2. (ii)

    B𝖼𝗅(X)X.

Proof.

Let B be a k-fault-tolerant basis of . If B𝖼𝗅(X), then the claim is straightforward because in this case, 𝖼𝗅(X)=E() and r=h. We can therefore select B to be the set of k+r arbitrary elements of X by Observation 7. We hence assume from now on that B𝖼𝗅(X).

Consider a k-fault-tolerant basis B satisfying (i), that is, B𝖼𝗅(X)=B𝖼𝗅(X), such that the size of B(𝖼𝗅(X)X) is minimum. We claim that B satisfies (ii), that is, B𝖼𝗅(X)X. Assume towards a contradiction that B(𝖼𝗅(X)X) and there is an element xB(𝖼𝗅(X)X). Let Y=B{x}. Note that Y is not a k-fault-tolerant basis of . Hence, there is a set FY of size at most k such that 𝗋𝖺𝗇𝗄(YF)<r. Notice that 𝗋𝖺𝗇𝗄(BF)=r implies 𝗋𝖺𝗇𝗄(YF)=r1. Denote by the family of all sets FY of size at most k such that 𝗋𝖺𝗇𝗄(YF)=r1. For each F, let ZFY be an inclusion-maximal independent set in YF and let 𝒵={ZFF}. Note that 𝖼𝗅(ZF)=𝖼𝗅(YF) and therefore 𝗋𝖺𝗇𝗄(ZF)=r1 for each F. By Proposition 6, it holds that |Y|(k+1)r1. Hence, |𝒵|((k+1)r1r1)[(k+1)r]r1. We next show that |𝖼𝗅(ZF)X|h1 for each F.

To this end, assume towards a contradiction that |𝖼𝗅(ZF)X|h. Since X is h-uniform, we obtain that X𝖼𝗅(𝖼𝗅(ZF)X). Then 𝖼𝗅(X)𝖼𝗅(𝖼𝗅(ZF)X)𝖼𝗅(ZF) and, in particular, x𝖼𝗅(ZF)=𝖼𝗅(YF). However, in this case, BF=(Y{x})F𝖼𝗅(YF). Since B is a k-fault-tolerant basis, we have that 𝗋𝖺𝗇𝗄(YF)=𝗋𝖺𝗇𝗄(BF)=r contradicting F.

Recall that |X|(h1)[(k+1)r]r1+(k+1)r and B has at least one element outside X. Then, |B|(k+1)r and therefore |XB|(h1)[(k+1)r]r1+1 by Proposition 6. Since |𝒵|<[(k+1)r]r1 and, for each F, |𝖼𝗅(ZF)X|h1, a simple counting argument shows that there exists an element yXB such that y𝖼𝗅(ZF) for all F. Let B=Y{y}=(B{x}){y}. Note that by definition, (i) B𝖼𝗅(X)=B𝖼𝗅(X), (ii) |B(𝖼𝗅(X)X)|<|B(𝖼𝗅(X)X)|, and (iii) |B|=|B|. We next show that B is a k-fault-tolerant basis. Afterwards, we will show that this contradicts our choice of B.

Towards the former, let FB be of size at most k. We prove that 𝗋𝖺𝗇𝗄(BF)=r. If 𝗋𝖺𝗇𝗄(YF)=r, then 𝗋𝖺𝗇𝗄(BF)𝗋𝖺𝗇𝗄(YF)=r. So we assume from now on that 𝗋𝖺𝗇𝗄(YF)<r. Then, 𝗋𝖺𝗇𝗄(YF)=r1 as shown above. Assume towards a contradiction that yF. Since yB, we have that F=(F{y}){x} is a subset of B of size at most k. Since B is a k-fault-tolerant basis, 𝗋𝖺𝗇𝗄(BF)=r. However, BF=YF and 𝗋𝖺𝗇𝗄(YF)=r, contradicting our assumption that 𝗋𝖺𝗇𝗄(YF)<r. Hence, yF and therefore FY. Recall that 𝗋𝖺𝗇𝗄(YF)=r1. This implies that F and ZF𝒵. Since y𝖼𝗅(ZF) by the choice of y, 𝗋𝖺𝗇𝗄(BF)=𝗋𝖺𝗇𝗄((YF){y})>𝗋𝖺𝗇𝗄(YF)=r1. Thus, 𝗋𝖺𝗇𝗄(BF)=r.

Since 𝗋𝖺𝗇𝗄(BF)=r for every FB of size at most k and |B|=|B|, we have that B is a k-fault-tolerant basis. However, we also obtain that (i) B𝖼𝗅(X)=B𝖼𝗅(X) and (ii) |B(𝖼𝗅(X)X)|<|B(𝖼𝗅(X)X)| contradicting the choice of B. This shows that B𝖼𝗅(X)X and completes the proof.

Now we show how to construct a set W of important elements of bounded size.

Lemma 9.

There is an algorithm that, given a matroid of rank r1 with {e}() for each eE() and an integer k0, outputs a set WE() of at most rr2[(k+1)r]r3 elements in (rk)𝒪(r2)n𝒪(1) time such that has a k-fault-tolerant basis if and only if has a k-fault-tolerant basis BW.

Proof.

Let be a matroid of rank r1 such that {e}() for any eE() and let k be a non-negative integer. We construct a recursive branching algorithm Important(,X) that takes as input a matroid and a non-empty independent set X(), and outputs a set Y𝖼𝗅(X) of size at most |X||X|2[(k+1)r]r|X|2 with the property that for any k-fault-tolerant basis B of , there is a k-fault-tolerant basis B such that

  1. (i)

    B𝖼𝗅(X)=B𝖼𝗅(X) and

  2. (ii)

    B𝖼𝗅(X)Y.

Let h=|X|. The base case is h=1, where we do the following:

  • Compute 𝖼𝗅(X).

  • If |𝖼𝗅(X)|<(k+1)r, then set Y:=𝖼𝗅(X) and output it.

  • Otherwise, define Y to be the set of (k+1)r arbitrary elements of 𝖼𝗅(X) and output it.

For h>1, we do the following:

  • Compute 𝖼𝗅(X).

  • If |𝖼𝗅(X)|(h1)[(k+1)r]r1+(k+1)r, then set Y:=𝖼𝗅(X), output it, and stop.

  • Find a h-uniform set Z𝖼𝗅(X) that either has size (h1)[(k+1)r]r1+(k+1)r or is an inclusion-maximal h-uniform set of size at most (h1)[(k+1)r]r1+(k+1)r1.

  • If |Z|=(h1)[(k+1)r]r1+(k+1)r, then set Y:=Z and output it.

  • If Z is an inclusion-maximal h-uniform set of size at most (h1)[(k+1)r]r1+(k+1)r1, then output Y:=SZ s.t. |S|=h1YS, where YS is the output of Important(,S).

To compute an h-uniform set Z, we apply the following greedy procedure:

  • Initially, set Z:=X.

  • While Z(h1)[(k+1)r]r1+(k+1)r1, do the following:

    • For every x𝖼𝗅(X)Z, check whether Z{x} is h-uniform and set Z:=Z{x} if this holds.

    • If Z{x} is not h-uniform for all x𝖼𝗅(X)Z, then output Z and stop.

  • If Z=(h1)[(k+1)r]r1+(k+1)r, then output Z.

The crucial property of the algorithm is given in the following claim whose proof combines Lemma 8 and induction on h. Here and further, the proofs of the statements labeled () are omited in this extended abstract and can be found in the full version of the paper [4].

Claim 10 ().

Important(,X) outputs a set Y𝖼𝗅(X) with the property that for any k-fault-tolerant basis B of , there is a k-fault-tolerant basis B such that

  1. (i)

    B𝖼𝗅(X)=B𝖼𝗅(X) and

  2. (ii)

    B𝖼𝗅(X)Y.

It remains to analyze the size of Y and the running time. We next show an upper bound on the size of Y of |Y|hh2[(k+1)r]rh2. We prove this via induction on h.

For h=1, note that |Y|(k+1)rhh2[(k+1)r]rh2. For h2, consider any independent set SE() of size h1. The algorithm outputs the set YS, which by the induction hypothesis, has size at most Nh1=(h1)(h1)2[(k+1)r]r(h1)2. By construction, we have

|Y|max{(h1)[(k+1)r]r1+(k+1)r,((h1)[(k+1)r]r1+(k+1)r1h1)Nh1}.

Observe first that

(h1)[(k+1)r]r1+(k+1)rh[(k+1)r]rhh2[(k+1)r]rh2. (1)

For the second option, note that

((h1)[(k+1)r]r1+(k+1)r1h1)Nh1 (h[(k+1)r]r)hNh1
(h[(k+1)r]r)h(h1)(h1)2[(k+1)r]r(h1)2
hh[(k+1)r]rhhh2h[(k+1)r]r(h2h)
hh2[(k+1)r]rh2.

Combining this equation with Equation 1, we obtain the required upper bound for |Y|.

Finally, we evaluate the running time of Important and show that Important(,X) runs in (rk)𝒪(rh2)n𝒪(1) time. To this end, notice that 𝖼𝗅(X) can be constructed in polynomial time in the oracle model. To construct the h-uniform set Z of size h(rk)𝒪(r), we use the greedy procedure where for each x𝖼𝗅(X)Z for the considered Z, we go over all subsets S of Z of size h1 and check whether S{x} is independent using the oracle. As hr, the construction of Z can be done in (kr)𝒪(rh)n𝒪(1) time. The algorithm makes (rk)𝒪(rh) recursive calls and the depth of the search tree is at most h. Summarizing, we obtain that the overall running time is (rk)𝒪(rh2)n𝒪(1).

To complete the proof and construct W, we call Important(,X) for an arbitrary basis X of and set W=Y for the output set of the algorithm. Note that a basis can be found in polynomial time using the independence oracle. Then Claim 10 implies that if has a k-fault-tolerant basis, then it also has one in W. Note that the other direction is trivial as WE(). This concludes the proof.

We are now ready to prove Theorem 1, which we restate here for convenience.

Theorem 1. [Restated, see original statement.]

Fault-Tolerant Basis can be solved in (kr)𝒪(kr4)n𝒪(1) time on n-element matroids of rank at most r given by independence oracles.

Proof.

Let be a matroid of rank r and let k0 be an integer. Fault-Tolerant Basis is trivial for r=0 and we can assume that r1. Notice that loops of , that is, elements e such that {e}() are irrelevant – a loop e is not included in any k-fault-tolerant basis and e𝖼𝗅(X) for any set XE(). Hence, we can preprocess and delete the loops. From now on, we assume that {e}() for every eE().

We apply the algorithm from Lemma 9, and in time (rk)𝒪(r3)n𝒪(1), find a set WE() of size at most rr2[(k+1)r]r3 such that whenever has a k-fault-tolerant basis, has a k-fault-tolerant basis BW. We consider all candidate subsets B of W with |B|(k+1)r using the upper bound for the size of a k-fault-tolerant basis from Proposition 6. This can be done in (kr)𝒪(kr4) time. For each candidate set B of size at most (k+1)r, we verify whether B is a k-fault-tolerant basis as follows. In 𝒪([(k+1)r]k) time, we check whether 𝗋𝖺𝗇𝗄(BF)=r for every subset FB of size at most k. Among all candidate sets satisfying the above property, we select a set of minimum size which is a k-fault-tolerant basis of . The overall running time is (kr)𝒪(kr4)n𝒪(1). This concludes the proof.

5 Partition matroids

In this section, we prove Proposition 5. The proof is based on the following structural lemma.

Lemma 11.

Let be a partition matroid with unit capacities for a partition (P1,,Pd) of the ground set. Let XE() and let k0 and r1 be integers. Then, the following properties hold.

  1. (i)

    If there is an integer s1 such that |X|=s(r1)+k+1 and |XPi|s for every i{1,,d}, then for any set FX of size at most k, 𝗋𝖺𝗇𝗄(XF)r.

  2. (ii)

    If X is an inclusion-minimal set such that for any set FX of size at most k, 𝗋𝖺𝗇𝗄(XF)r, then there is an integer s1 such that |X|=s(r1)+k+1 and |XPi|s for every i{1,,d}.

Proof.

To show (i), suppose that |X|=s(r1)+k+1 and |XPi|s for each i{1,,d} for some integer s1. Consider any subset FX of size at most k. Since |XPi|s for every i{1,,d}, it holds that |(XF)Pi|s and hence |(XF)Pi|>0 for at least |XF|s sets Pi. Since is a partition matroid with unit capacities, this is also a lower bound on 𝗋𝖺𝗇𝗄(XF) and therefore

𝗋𝖺𝗇𝗄(XF)|XF|ss(r1)+1sr.

This proves that 𝗋𝖺𝗇𝗄(X)r and 𝗋𝖺𝗇𝗄(XF)r for any set FX of size at most k.

To prove (ii), suppose that X is an inclusion-minimal set with 𝗋𝖺𝗇𝗄(X)r such that for any set FX of size at most k, 𝗋𝖺𝗇𝗄(XF)r holds. We assume without loss of generality that |XP1||XPd|.

If r=1, then we set s=max{|XPi|1id}. Trivially, |X|k+1 and |XPi|s for every i{1,,d}. We next show that |X|=k+1. Assume towards a contradiction that |X|>k+1. Any subset XX of size k+1 satisfies |XPi|s for every i{1,,d}. Hence, 𝗋𝖺𝗇𝗄(XF)>1 for any set F of size at most k by (i). This contradicts the the minimality of X and shows |X|=k+1.

If r2, then |XPr1|1 and we set s=|XPr1|. We will next show that |X|=s(r1)+k+1 and |XPi|s for every i{1,,d}. Let Y=j=1r1(XPj) and Z=j=rd(XPj). By definition of s, |Y|s(r1).

If |Z|k, then 𝗋𝖺𝗇𝗄(XZ)=r1<r, contradicting the choice of X. Thus, |Z|k+1 and |X|=|Y|+|Z|s(r1)+k+1. There exist YY such that |YPj|=s for each j{1,,r1}, and ZZ such that |Z|=k+1. Consider X=YZ. By definition, |XPi|s for every i{1,,d}. Then, by (i), we have that 𝗋𝖺𝗇𝗄(X)r and for any set FX of size at most k, 𝗋𝖺𝗇𝗄(XF)r. By the minimality of X, we conclude that X=X. This proves (ii).

We are now ready to prove Proposition 5, which we restate here.

Proposition 5. [Restated, see original statement.]

Given an n-element partition matroid with unit capacities together with a weight function w:E()0 and integers r,k0, one can find in 𝒪(n2) time either a set XE() of minimum weight such that, for any set FX of size at most k, it holds that 𝗋𝖺𝗇𝗄(XF)r or correctly decide that such a set does not exist.

Proof.

Consider a weighted partition matroid with unit capacities and a weight function w:E()0. Let k0 and r0 be integers. Let also (P1,,Pd) be the partition of E() defining . If r=0, then the claim of the theorem is trivial as X= is a solution. Thus, we can assume that r1.

For an integer s1, we say that s is feasible if there exists a set XE() with |X|=s(r1)+k+1 such that |XPi|s for every i{1,,d}. For each integer 1smax{|Pi|1id}, we check whether s is feasible. This can be done by checking whether i=1d|min{|Pi|,s}|s(r1)+k+1. If there is no feasible integer, then we conclude that there is no XE() with the property that 𝗋𝖺𝗇𝗄(XF)r for any subset FX of size at most k by Lemma 11. Otherwise, for every feasible s, we greedily choose a set X of minimum weight such that |X|=s(r1)+k+1 and |XPi|s for every i{1,,d}. Notice that the selection of such a set is equivalent to finding a minimum weight independent set of size s(r1)+k+1 in the partition matroid for (P1,,Pd) with the capacities (c1,,cd) where ci=min{s,|Pi|} for each i{1,,d}. By the well-known matroid properties [21], the greedy algorithm finds such a set X. By Lemma 11, we conclude that X is a minimum weight set such that for any set FX of size at most k, 𝗋𝖺𝗇𝗄(XF)r. This concludes the description of our algorithm and its correctness proof.

To evaluate the running time, notice that the elements of can be sorted by their weight in 𝒪(nlogn) time. Then we have at most n choices of s and for each s, the greedy algorithm works in 𝒪(n) time. Thus, the overall running time is in 𝒪(n2), concluding the proof.

As a corollary, we obtain the following for general matroids of rank at most two.

Corollary 12 ().

Weighted Fault-Tolerant Basis can be solved in 𝒪(n2) on matroids of rank at most two given by an independence oracle.

6 Complexity dichotomy for the parameterization by rank

In this section, we prove Theorem 4 which we restate here for convenience.

Theorem 4. [Restated, see original statement.]

For any integer r3, it is NP-hard to decide whether a linear matroid of rank r over rationals given together with integers k and b has a k-fault-tolerant basis of size at most b. For r2, Weighted Fault-Tolerant Basis can be solved in 𝒪(n2) on matroids given by an independence oracle.

Proof.

The claim for r2 is proven in Corollary 12. Thus, it remains to show the computational lower bound for r3. We show the claim for r=3 and then explain how to extend it for any r3. We reduce from General Position Subset Selection. Recall that a set P of points on the Euclidean plane is said to be in general position if there are no three points on the same line on the plane. General Position Subset Selection is defined as follows. Given a set P of point on the plane and an integer p1, decide whether there is a subset QP of at least p points in general position. The problem was shown to be NP-hard by Froese et al. [16] and the result holds for points with rational coordinates.

Let (P={(x1y1),,(xnyn)},p) be an instance of General Position Subset Selection. We assume without loss of generality that p3 as any set of at most two points is in general position. We set k=p3, construct the set E={(x1y11),,(xnyn1)} of vectors, and define to be the linear matroid with the ground set E over rationals.

Note that 𝗋𝖺𝗇𝗄()3 and that three distinct points (xhyh), (xiyi), and (xjyj) of P are not on the same line if and only if 𝗋𝖺𝗇𝗄({(xhyh1),(xiyi1),(xjyj1)})=3. This implies that for any I{1,,n}, the points of {(xiyi)iI}P are in general position if and only if {(xiyi1)iI}E is a 3-uniform set for . Hence, P has a subset of at least p points in general position if and only if there is a 3-uniform subset of E of size at least p. By Proposition 6, a k-fault-tolerant basis of has size at least p=k+3. By Observation 7, has a k-fault-tolerant basis of size p if and only if (P,p) is a yes-instance of General Position Subset Selection. This concludes the proof for r=3.

To see the claim for r>3, we perform the same reduction but in r dimensions. The constructed vectors have a 0 in all but the first three dimensions (where they have the entries as constructed above). For each 4ir, we then add k+1 vectors with zero-entries everywhere except for dimension i, where the entry is 1. Note that any k-fault-tolerant basis of the linear matroid over the constructed vectors has to contain all (r3)(k+1) newly added vectors. Moreover, it has to contain a set P of vectors such that after removing any k of them, the first three dimensions have to be spanned by the remaining vectors. This is equivalent to the case r=3 and concludes the proof.

7 Conclusion

In this paper, we initiate the study of the parameterized complexity of Fault-Tolerant Basis. Our main result is that the problem is fixed-parameter tractable when parameterized by both k and rank r of the input matroid. This positive algorithmic result is complemented by computational lower bounds showing NP-hardness for constant values for any one of the two parameters alone. Our results lead to several open questions.

First, we do not know whether our FPT result from Theorem 1 could be extended for Weighted Fault-Tolerant Basis. Our approach based on the choice of h-uniform sets is tailored for the unweighted case, and one may need different techniques in the presence of weights.

Second, is it possible to extend our result to the non-uniform model introduced by Adjiashvili et al. [1]? Here, we assume that the set of elements of a matroid is partitioned into two subsets S and V of safe and vulnerable elements, respectively. Then, the task is to either find a set BE() of minimum size such that for any sets FVB of size at most k, 𝗋𝖺𝗇𝗄(F)=𝗋𝖺𝗇𝗄() or correctly report that such a set does not exist. Fault-Tolerant Basis is the special case of this problem with S=.

Third, can our results be extended to the model introduced by Adjiashvili et al. [2] where not arbitrary sets of k elements can fail but possible failure scenarios are part of the input?

Finally, observe that our computational lower bounds from Proposition 2, Observation 3, and Theorem 4 do not exclude efficient algorithms for Fault-Tolerant Basis on special classes of matroids. In particular, we proved in Proposition 5 that Weighted Fault-Tolerant Basis can be solved in polynomial time on truncations of partition matroids with unit capacities. While it is straightforward to see that Weighted Fault-Tolerant Basis can be solved in polynomial time for partition matroids with arbitrary capacities,111Given a partition matroid defined by a partition (P1,,Pd) of the ground set and a d-tuple of capacities (c1,,cd), to solve Weighted Fault-Tolerant Basis, we have to choose ci+k elements of minimum weight from each Pi. it is not clear whether the problem can be solved in polynomial time on their truncations. The problem complexity for other fundamental classes of matroids, like transversal matroids and gammoids, is another interesting open question.

References

  • [1] David Adjiashvili, Felix Hommelsheim, Moritz Mühlenthaler, and Oliver Schaudt. Fault-tolerant edge-disjoint s-t paths – beyond uniform faults. In Proceedings of the 18th Scandinavian Symposium and Workshops on Algorithm Theory (SWAT), pages 5:1–5:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPICS.SWAT.2022.5.
  • [2] David Adjiashvili, Sebastian Stiller, and Rico Zenklusen. Bulk-robust combinatorial optimization. Mathematical Programming, 149(1-2):361–390, 2015. doi:10.1007/S10107-014-0760-6.
  • [3] Ishan Bansal, Joseph Cheriyan, Logan Grout, and Sharat Ibrahimpur. Improved approximation algorithms by generalizing the primal-dual method beyond uncrossable functions. In Proceedings of the 50th International Colloquium on Automata, Languages, and Programming (ICALP), pages 15:1–15:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ICALP.2023.15.
  • [4] Matthias Bentert, Fedor V. Fomin, Petr A. Golovach, and Laure Morelle. Fault-tolerant matroid bases, 2025. doi:10.48550/arXiv.2506.22010.
  • [5] Matthias Bentert, Jannik Schestag, and Frank Sommer. On the complexity of finding a sparse connected spanning subgraph in a non-uniform failure model. In Proceedings of the 18th International Symposium on Parameterized and Exact Computation (IPEC), pages 4:1–4:12. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.IPEC.2023.4.
  • [6] Dimitris Bertsimas, David B. Brown, and Constantine Caramanis. Theory and applications of robust optimization. SIAM Review, 53:464–501, 2011. doi:10.1137/080734510.
  • [7] Sylvia C. Boyd, Joseph Cheriyan, Arash Haddadan, and Sharat Ibrahimpur. Approximation algorithms for flexible graph connectivity. In Proceedings of the 41st IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 9:1–9:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.FSTTCS.2021.9.
  • [8] Parinya Chalermsook, Chien-Chung Huang, Danupon Nanongkai, Thatchaphol Saranurak, Pattara Sukprasert, and Sorrachai Yingchareonthawornchai. Approximating k-edge-connected spanning subgraphs via a near-linear time LP solver. In Proceedings of the 49th International Colloquium on Automata, Languages, and Programming (ICALP), pages 37:1–37:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPICS.ICALP.2022.37.
  • [9] Chandra Chekuri and Rhea Jain. Approximation algorithms for network design in non-uniform fault models. In Proceedings of the 50th International Colloquium on Automata, Languages, and Programming (ICALP), pages 36:1–36:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ICALP.2023.36.
  • [10] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Daniel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [11] Alex G. Dimakis, P. Brighten Godfrey, Yunnan Wu, Martin J. Wainwright, and Kannan Ramchandran. Network coding for distributed storage systems. IEEE Transactions on Information Theory, 56(9):4539–4551, 2010. doi:10.1109/TIT.2010.2054295.
  • [12] Mitre Costa Dourado, Dirk Meierling, Lucia D Penso, Dieter Rautenbach, Fabio Protti, and Aline Ribeiro de Almeida. Robust recoverable perfect matchings. Networks, 66(3):210–213, 2015. doi:10.1002/NET.21624.
  • [13] Michael Elad. Sparse and Redundant Representations: From Theory to Applications in Signal and Image Processing. Springer, 2010. doi:10.1007/978-1-4419-7011-4.
  • [14] Cristina G. Fernandes. A better approximation ratio for the minimum size k-edge-connected spanning subgraph problem. Journal of Algorithms, 28(1):105–124, 1998. doi:10.1006/JAGM.1998.0931.
  • [15] Fedor V. Fomin, Petr A. Golovach, Daniel Lokshtanov, and Saket Saurabh. Covering vectors by spaces: Regular matroids. SIAM Journal on Discrete Mathematics, 32(4):2512–2565, 2018. doi:10.1137/17M1151250.
  • [16] Vincent Froese, Iyad A. Kanj, André Nichterlein, and Rolf Niedermeier. Finding points in general position. International Journal of Computational Geometry and Applications, 27(4):277–296, 2017. doi:10.1142/S021819591750008X.
  • [17] Harold N. Gabow, Michel X. Goemans, Éva Tardos, and David P. Williamson. Approximating the smallest k-edge connected spanning subgraph by LP-rounding. Networks, 53(4):345–357, 2009. doi:10.1002/NET.20289.
  • [18] Felix Hommelsheim, Moritz Mühlenthaler, and Oliver Schaudt. How to secure matchings against edge failures. SIAM Journal on Discrete Mathematics, 35(3):2265–2292, 2021. doi:10.1137/20M1336229.
  • [19] Samir Khuller and Uzi Vishkin. Biconnectivity approximations and graph carvings. In Proceedings of the 24th Annual ACM Symposium on Theory of Computing (STOC), pages 759–770. ACM, 1992. doi:10.1145/129712.129786.
  • [20] Daniel Lokshtanov, Pranabendu Misra, Fahad Panolan, and Saket Saurabh. Deterministic truncation of linear matroids. ACM Transactions on Algorithms, 14(2):14:1–14:20, 2018. doi:10.1145/3170444.
  • [21] James G. Oxley. Matroid theory. Oxford University Press, 1992.