The complexity landscape of decompositional parameters for ILP: Programs with few global variables and constraints

Integer Linear Programming (ILP) has a broad range of applications in various areas of artiﬁcial intelligence. Yet in spite of recent advances, we still lack a thorough understanding of which structural restrictions make ILP tractable. Here we study ILP instances consisting of a small number of “global” variables and/or constraints such that the remaining part of the instance consists of small and otherwise independent components; this is captured in terms of a structural measure we call fracture backdoors which generalizes, for instance, the well-studied class of N -fold ILP instances. Our main contributions can be divided into three parts. First, we formally develop fracture backdoors and obtain exact and approximation algorithms for computing these. Second, we exploit these backdoors to develop several new parameterized algorithms for ILP; the performance of these algorithms will naturally scale based on the number of global variables or constraints in the instance. Finally, we complement the developed algorithms with matching lower bounds. Altogether, our results paint a near-complete complexity landscape of ILP with respect to fracture backdoors. 1 © 2021 The Author(s). Published by Elsevier B.V. This is an open access article under the CC BY license (http://creativecommons.org/licenses/by/4.0/).


Introduction
Integer Linear Programming (ILP) is the archetypical representative of an NP-complete optimization problem and has a broad range of applications in various areas of artificial intelligence. In particular, a wide variety of problems in artificial intelligence are efficiently solved in practice via translation into ILP, including problems from areas such as planning [45,46], process scheduling [17], packing [37], vehicle routing [44], and network hub location [2].
In spite of recent advances [20,22,30], we still lack a deep understanding of which structural restrictions make ILP tractable. The goal of this line of research is to identify structural properties (formally captured by a numerical structural parameter k) which allow us to solve ILP efficiently. In particular, one seeks to either solve an ILP instance I in time f (k) · |I| O(1) (a so-called fixed-parameter algorithm), or at least in time |I| f (k) (a so-called XP algorithm), where f is a computable function. This approach lies at the core of the now well-established parameterized complexity paradigm [9,6] and has yielded deep results capturing the tractability and intractability of numerous prominent problems in diverse areas of computer science-such as Constraint Satisfaction, SAT, and a plethora of problems on directed and undirected graphs. In general, structural parameters can be divided into two groups based on the way they are designed. Decompositional parameters capture the structure of instances by abstract tools called decompositions; treewidth is undoubtedly the most prominent example of such a parameter, and previous work has obtained a detailed complexity map of ILP with respect to the treewidth of natural graph representations of instances [20,22]. On the other hand, backdoors directly measure the "distance to triviality" of an instance: the number of simple operations required to put the instance into a well-defined, polynomially tractable class. While the backdoor approach has led to highly interesting results for problems such as Constraint Satisfaction [25] and SAT [24], it has so far been left mostly unexplored in the arena of ILP.

Our contribution
Here, we initiate the study of backdoors to triviality for ILP by analyzing backdoors which fracture the instance into small, easy-to-handle components. Such fracture backdoors can equivalently be viewed as measuring the number of global variables or global constraints in an otherwise "compact" instance; in fact, we identify and analyze three separate cases depending on whether we allow global variables only, global constraints only, or both. We obtain a near-complete complexity landscape for the considered parameters: in particular, we identify the circumstances under which they can be used to obtain fixedparameter and XP algorithms for ILP, and otherwise prove that such algorithms would violate well-established complexity assumptions. Our results are summarized in Table 1 (formal definitions are given in Section 3).
As is evident from the table, backdoor size on its own is not sufficient to break the NP-hardness of ILP; this is far from surprising, and the same situation arose in previous work on treewidth. However, while positive results on treewidth (as well as other considered decompositional parameters such as torso-width [22]) required the imposition of domain restrictions on variables, in the case of backdoors one can also deal with instances with unrestricted variable domains-by instead restricting the values of coefficients which appear in the ILP instance. Here, we distinguish three separate cases (corresponding to three rows in Table 1): coefficients bounded by the parameter value, coefficients which are encoded in unary, and no restrictions. It is worth noting that in the case of treewidth, ILP remains NP-hard even when coefficients are restricted to ±1 and 0 [20].
Our results in row 1 represent a direct generalization of three extensively studied classes of ILP, specifically n-fold ILP, two-stage stochastic ILP and 4-block N-fold ILP [7,39]. The distinction lies in the fact that while in the case of all three previously mentioned special cases of ILP the ILP matrix must be completely uniform outside of its global part, here we impose no such restriction. The only part of our complexity landscape which remains incomplete, the case of mixed backdoors combined with bounded coefficients, then corresponds to resolving a challenging open problem in the area of N-folds: the fixed-parameter (in)tractability of 4-block N-fold ILP [27]. We also prove that ILP parameterized by coefficients and a variable or constraint backdoor (i.e., the parameterizations for which we obtain fixed-parameter algorithms) does not admit a polynomial kernel, unless NP ⊆ co-NP/poly.
In the intermediate case of coefficient values encoded in unary (row 2), we surprisingly show that ILP remains polynomially tractable when the number of global constraints is bounded by a constant, but becomes NP-hard if we use global variables instead. To be precise, we obtain an XP algorithm parameterized by constraint backdoors, rule out the existence of a fixed-parameter algorithm for this case, and also rule out XP algorithms for variable and mixed backdoors. These also represent our most technical results: especially the XP algorithm requires the combination of deep linear-algebraic techniques with tools from the parameterized complexity toolbox.
Last but not least, all our algorithmic results first require us to compute a fracture backdoor. It turns out that computing fracture backdoors in ILP is closely related to solving the Vertex Integrity problem [10] on bipartite graphs; unfortunately, while the problem has been studied on numerous graph classes including cobipartite graphs, its complexity remained open on bipartite graphs. Here we obtain both an exact fixed-parameter algorithm as well as a polynomial time approximation algorithm for finding fracture backdoors. As an additional result, we also show that the problem is NP-complete using a novel reduction.
The paper is structured as follows. After introducing the necessary notions and notation in the preliminaries, we proceed to formally define our parameter and develop algorithms for computing the desired backdoors. We then present our results separated by the type of restrictions put on the size of the matrix coefficients in the remaining sections.

Related and follow-up work
This paper represents a natural continuation of previous work aimed at identifying new classes of integer linear programs that can be solved efficiently via the use of decompositional parameters which take into account the structure of variableconstraint interactions [20,22,30]. However, efforts to characterize tractable classes of ILPs and obtain algorithms with better worst-case runtime guarantees for the problem date back to the classical works of Papadimitriou [40], Lenstra [36] and others [31,19].
At this time, the use of decompositional parameters for ILP remains a dynamic research direction. First, Chen and Marx [4] used Graver-basis driven approach for block structured matrices, the so-called tree-fold ILPs, and showed that these ILPs are fpt for the combined parameter that, among others, contains the depth of the tree associated with the constraint matrix. Indeed, follow-up work by Koutecký, Levin and Onn [35] after the presentation of this paper generalized Corollary 13 by using Graver-best oracles. Independently, Eisenbrand, Hunkenschröder and Klein also generalized Corollary 13 in their recent work [13]; see also the full joint version on the arXiv repository [14]. It is worth noting that these works considered mainly the parameterizations for dual graph and shown that ILP is fixed-parameter tractable with respect to the combined parameter largest number in the constraint matrix (in absolute value) and treedepth (which is strictly generalizing variable fractioning number). The so-called dual-treedepth can in fact be generalized to a parameter branch-dept [3]; which is notably invariant under row-equivalence. For the parameterizations by primal-treedepth the first explicit bound for the parameter dependence was given by Klein [32] (improving upon previously known existential results [26,35]). Finally, with respect to the structure of the variable-constraints interaction graph the fractioning number is thus far the most general parameter (when combined with the largest coefficient) leading to an XP algorithm. This cannot be generalized to treedepth, since ILP is NP-hard for constant incidence treedepth even for binary matrices [12].
A detailed overview of the recent developments in the use of decompositional and structural parameters for solving ILP and its variants can be found in the recent survey dedicated to this topic [21]; see also a related survey on block structured matrices by Chen [5].

Preliminaries
We will use standard graph terminology, see for instance the textbook by Diestel [8]. In the following let A be a n × m matrix and let C and R be a subset of columns and rows of A, respectively. We denote by A (R,C) the submatrix of A restricted to the columns in C and the rows in R. We also denote by A ( * ,C) and A (R, * ) the submatrix of A restricted to the columns in C and the submatrix of A restricted to the rows in R, respectively. We denote by c A the maximum absolute value of any entry of A and by det(A) the determinant of A. For a vector b of size n, we will use b[i] to denote its i-th entry and we denote by c b the maximum absolute value of any entry of b. We will also use the two following well-known facts [43].

Integer linear programming
For our purposes, it will be useful to consider ILP instances which are in equation form. Formally, let an ILP instance I be a tuple (A, x, b, l, u, η), where: • A is a n × m matrix of integers (the constraint matrix), • x is a vector of variables of size m, • b is an integer vector of size n (the right-hand side), • l, u are vectors of size m containing Z ∪ {±∞} as elements (the lower and upper bounds, respectively), and • η is an integer vector of size m (the optimization function).
Let A be the i-th row of A; then we will call Ax = b[i] a constraint of I. We will use var(I) to denote the set of variables (i.e., the elements of x), and F (I) (or just F ) to denote the set of constraints. For a subset U of var(I) ∪ F (I), we denote by C (U ) the columns of A corresponding to variables in U and by R(U ) the rows of A corresponding to constraints in U .
A assignment α is a mapping from var(I), denoted by var(α), to Z. An assignment α is called feasible if it 1. satisfies every constraint in F , i.e., if A i α(x) = b[i] for each i-th row A i of A, and 2. satisfies all the upper and lower bounds, i.e., Furthermore, α is called a solution if the value of ηα(x) is maximized over all feasible assignments; observe that the existence of a feasible assignment does not guarantee the existence of a solution (there may exist an infinite sequence of feasible assignments α with increasing values of ηα(x); in this case, we speak of unbounded instances). Given an instance I, the task in the ILP problem is to compute a solution for I or correctly determine that no solution exists. We remark that other formulations of ILP exist (e.g., a set of inequalities over variables); it is well-known that these are equivalent and can be transformed into each other in polynomial time [43]. Moreover, such transformations will only change our parameters (defined in Section 3) by a constant factor.
Aside from general integer linear programming, we will also be concerned with two subclasses of the problem.
1. ILP-feasibility is formulated equivalently as ILP, with the restriction that η must be the 0-vector. All hardness results for ILP-feasibility immediately carry over to ILP. 2. Unary ILP is the class of all ILP instances which are supplied in a unary bit encoding; in other words, the input size of Unary ILP upper-bounds not only the number of variables and constraints, but also the absolute values of all numbers in the input. Unary ILP remains NP-complete in general, but in our setting there will be cases where its complexity will differ from general ILP.
Combining both restrictions gives rise to Unary ILP-feasibility.
There are several ways of naturally representing ILP instances as graphs. The representation that will be most useful for our purposes will be the so-called incidence graph: the incidence graph G I of an ILP instance I is the graph whose vertex set is var(I) ∪ F (I) and two vertices s, t are adjacent iff s ∈ var(I), t ∈ F and s occurs in t with a non-zero coefficient. An instance I is a connected component of I if it is the subinstance of I corresponding to a connected component of G I ; formally, F (I ) ⊆ F (I) is the set of constraints that occur in a connected component of G I and η(I ), l , and u are the restriction of η(I), l, and u, respectively, to var(F (I )). For a set Z ⊆ F (I) ∪ var(I), we will also use I \ Z to denote the ILP instance obtained by removing all constraints in Z from F (I) and removing all variables in Z from all constraints in F (I) \ Z and from η, l and u.

Parameterized complexity
In parameterized algorithmics [18,38,9] the runtime of an algorithm is studied with respect to a parameter k ∈ N and input size n. The basic idea is to find a parameter that describes the structure of the instance such that the combinatorial explosion can be confined to this parameter. In this respect, the most favorable complexity class is FPT (fixed-parameter tractable) which contains all problems that can be decided by an algorithm running in time f (k) · n O (1) , where f is a computable function. Problems that can be solved in this time are called fixed-parameter tractable (fpt).
To obtain our lower bounds, we will need the notion of a parameterized reduction. Formally, a parameterized problem is a subset of * × N, where is the input alphabet. Let L 1 ⊆ * 1 × N and L 2 ⊆ * 2 × N be parameterized problems. A parameterized reduction (or fpt-reduction) from L 1 to L 2 is a mapping P : (ii) the mapping can be computed by an fpt-algorithm w.r.t. parameter k, and A topic related to fixed-parameter algorithms is kernelization. We say that the parameterized problem L ⊆ * × N admits a kernel if there is a function K : * × N → * × N computable in polynomial time such that (x, k) ∈ L if and only if K (x, k) ∈ L and |K (x, k)| ≤ h(k) for some computable function h. Informally, a kernel of L is a polynomial time algorithm which given an instance of L produces an equivalent instance of L whose size is bounded by a function of parameter of the original instance. We can understand a kernel as an effective preprocessing of an instance of some problem. It is wellknown [6] that a problem admits a fixed-parameter algorithm if and only if it admits a kernel. Thus, there is an interest in polynomial kernels, i.e., kernels for which the function h is polynomial. For proving that our problems do not admit polynomial kernels we use polynomial parameter transformations from other problems which do not admit polynomial kernels.

Definition 3 ([6]
). Let P , Q ⊆ * × N be two parameterized problems. An algorithm A is called a polynomial parameter transformation (PPT) from P to Q if given an instance (x, k) of problem P , A works in polynomial time and outputs an equivalent instance (y, ) of problem Q , i.e., (x, k) ∈ P if and only if (y, ) ∈ Q , such that ≤ p(k) for some polynomial It is known that if a parameterized problem P does not admit a polynomial kernel and there is a PPT from P to Q , then Q does not admit a polynomial kernel either [6].
Next, we will define the complexity classes needed to describe our lower bounds. The class W [1] captures parameterized intractability and contains all problems that are fpt-reducible to Independent Set when parameterized by the size of the solution. The following relations between the parameterized complexity classes hold: FPT ⊆ W [1] ⊆ XP, where the class XP contains all problems solvable in time O(n f (k) ) for a computable function f . Showing W[1]-hardness for a problem rules out the existence of an fpt-algorithm under standard complexity assumptions.
The class pNP is defined as the class of problems that are solvable by a non-deterministic Turing machine in fpt time. In our pNP-hardness proofs, we will make use of the following characterization of pNP-hardness given in the book by Flum and Grohe [18], Theorem 2.14: any parameterized problem that remains NP-hard when the parameter is set to some constant is pNP-hard. For problems in NP, we have W [1] ⊆ pNP and in particular showing pNP-hardness rules out the existence of algorithms with a running time of O(n f (k) ). For our algorithms, we will use the following result as a subroutine. Note that this is a streamlined version of the original statement of the theorem, as used in the area of parameterized algorithms [16].

ILP with structured matrices
Our results build on and extend the classical variable-dimension ILP techniques detailed for instance in the work of Onn and De Loera et al. [7,39,27]. Below, we provide a basic introduction to these techniques and related results. Let Here A 1 is an r × s matrix, A 2 is an r × t matrix, A 3 is an u × s matrix, A 4 is an u × t matrix, and N is a number of copies of A 2 , i.e., the matrix A (N) has size (r + N · u) × (s + N · t); for convenience, we let b A = max(r, s, t, u). We call an instance In the parameterized complexity setting, the above theorem yields an XP algorithm solving ILP parameterized by max(b A , c A ) if the matrix is a N-fold 4-block product. We note that the existence of a fixed-parameter algorithm for this problem remains a challenging open problem [27]. However, the problem is known to be fixed-parameter tractable when either A 1 and A 3 or A 1 and A 2 are omitted; these variants are called the N-fold ILP problem and the 2-stage stochastic ILP problem, respectively.

The fracture number
We are now ready to formally introduce the studied parameter and related notions. An ILP instance I is called -compact if each connected component of I contains at most variables and constraints; equivalently, each connected component of G I contains at most vertices. It is not difficult to observe that any -compact ILP instance can be solved in time at most O( ) · |I| due to Proposition 4; indeed, we can compute a solution for I by combining solutions for each connected component of I, and hence it suffices to apply Proposition 4 independently on each component.
A set Z ⊆ F ∪ var(I) is called a backdoor to -compactness if I \ Z is -compact; moreover, if Z ∩ F = ∅ then Z is called a variable-backdoor to -compactness, and if Z ∩ var(I) = ∅ then Z is a constraint-backdoor to -compactness. We use b (I) to denote the cardinality of a minimum backdoor to -compactness, and similarly b V (I) and b C (I) for variable-backdoors and constraint-backdoors to -compactness, respectively. It is easy to see that, depending on the instance, b V (I) can be arbitrarily larger or smaller than b C (I). On the other hand, b (I) ≤ min(b V (I), b C (I)).
Clearly, the choice of has a major impact on the size of backdoors to -compactness; in particular, b (I) could be arbitrarily larger than b +1 (I), and the same of course also holds for variable-and constraint-backdoors. Since we will be interested in dealing with cases where both and b (I) are small, we will introduce the fracture number p which provides bounds on both and b ; in particular, we let p(I) = min ∈N (max( , b (I))). Furthermore, we say that a backdoor Z witnesses p(I) if |Z | ≤ p(I) and I \ Z is p(I)-compact. We define p C (I) and p V (I) similarly, with b (I) replaced by b C (I) and b V (I), respectively. If the instance I is clear from the context, we omit the reference to I; see Fig. 1 for an example.
We remark that the fracture number represents a strict generalization of the parameter b A used in Theorems 5 and 6; in particular, p ≤ 2b A (and similarly for p V and p C for the latter two theorems). Moreover, the fracture number is well-defined for all ILP instances, not only for N-fold 4-block products. In this respect, N-fold 4-block products with bounded b A form the subclass of instances with bounded p such that each component must contain precisely the same submatrix. We will show next that this is indeed a very strong restriction by showing that there can be an arbitrary difference between the two parameters even if we allow permutations of rows and columns.
To see this, we will construct for every natural number h an ILP instance with matrix A such that p(A) ≤ 2 but A cannot be "represented" as an N-fold 4-block matrix of dimension less than h. More formally, we say that a matrix A can be represented as the N-fold 4-block of a block matrix B = , if there is an integer n such that A can be transformed using only row and column permutations into the n-fold 4-block of B.
Towards showing this, let h be an arbitrary natural number, and let I h be an ILP instance whose constraint matrix A h is Then, p(I h ) ≤ 2 since removing the only global variable (i.e., the first column of A h ) and the only global constraint (i.e., the first row of A h ) leaves only components containing one variable and one constraint. However, as we will show next A h cannot be represented as the N-fold 4-block of any block matrix of dimension smaller than h. In particular, we will show that in any representation of A h as the h -fold 4-block of a block matrix at least h. To see this, first note that h ≥ h since otherwise either the dimension of B 1 or the dimension of B 4 is at least h. For i ∈ {1, 4}, let o i and t i be the number of 1's respectively 2's that were originally on the diagonal of A h (i.e., before permuting) and are now in B i . Observe that after any sequence of row and column permutations, no pair of "1"s or "2"s that were originally on the diagonal of A h can be on the same row or column.
, which implies that o 4 ≥ ht 4 and therefore the dimension of B 4 is at least h, which concludes the argument.
This means that the parameters required when interpreting A h as an N-fold 4-block matrix are necessarily unbounded (even if we allow arbitrary permutations of rows and columns). Informally, our parameter is essentially equivalent to the generalization of N-fold 4-block, where the block matrices that are repeated along the diagonal as well as the block matrices that are repeated along the first row and column can be distinct. In other words, our results show that also the following kind of matrices allow for tractability of ILP (as long as the dimensions and coefficients of the involved block matrices, i.e., the matrices A 1 and A 1 i , . . . A N i for every i ∈ {2, 3, 4}, are considered as parameters): Informally, this is possible because we only allow for small coefficients and therefore the number of distinct matrices along 3, 4} is bounded in terms of the dimension and coefficients of these matrices. Finally, we want to note here that apart from providing a generalization of 4-block N-fold (as well as n-fold and 2-stage stochastic) ILPs another advantage of fracture number is that the structure can be efficiently identified using Theorem 8.

Computing the fracture number
Our evaluation algorithms for ILP require a backdoor set as part of their input. In this section we show how to efficiently compute small backdoor sets, i.e., we show how to solve the following problem.

Fracture Backdoor Detection (BD)
Instance: An ILP instance I and a natural number k. Parameter: k Question: Determine whether p(I) ≤ k and if so output a backdoor set witnessing this.
We also define the variants V-BD and C-BD that are concerned with finding a variable or a constraint backdoor, respectively, in the natural way. Observe that at its core the above problem and its variants are really a problem on the incidence graph of the ILP instance. Namely, the problems can be equivalently stated as the following graph problem.

Fracture Vertex Deletion (FVD)
Instance: It is worth noting that this graph problem is closely related to the so-called Vertex Integrity problem, which has been studied on a variety of graph classes, including co-bipartite graphs [10]. Unfortunately, to the best of our knowledge nothing is known about its complexity on bipartite graphs. To see that each variant of BD is equivalent to a specific subcase of the is an instance of FVD, then (I, k), where I is any ILP instance such that G I is isomorphic with G and var(I) = U , is an equivalent instance of V-BD. Note that such an instance I can for instance be obtained as follows: • for every vertex v ∈ U , I has one variable v with arbitrary domain, • for every vertex v ∈ W , I has one constraint with arbitrary non-zero coefficients on the variables in N G (v), To justify a parameterized complexity analysis of our detection problems, we first show NP-completeness of our problems. It is worth noting that the NP-completeness of Fracture Vertex Deletion was far from obvious at first glance due to the restriction to bipartite graphs; indeed, for instance the related problem of deleting at most k vertices such that the remaining graph only contains isolated vertices (Vertex Cover) is well-known to be polynomial on bipartite graphs.
Proof. Because of the equivalence between BD, V-BD, C-BD and the FVD problem, it is sufficient to show that FVD is NPcomplete for both choices of D. Because any solution to FVD can be verified in polynomial time, it holds that FVD is in NP.
Towards showing NP-hardness of FVD we give a polynomial-time reduction from a known variant of the 3-Satisfiability problem. Given a 3-CNF formula with variables x 1 , . . . , x n and clauses C 1 , . . . , C m such that every literal occurs in exactly two clauses (this variant of 3-Satisfiability is known to be NP-complete [23]), we construct the instance G, D, k of FVD as follows. We set k = n + 2m and the graph G will be the disjoint union of certain variable and clause gadgets introduced below plus connections between these variable and clauses gadgets. Namely, for every variable x i , the graph G contains the variable gadget G(x i ) with the following vertices and edges: • two vertices x i and x i , Moreover for every clause C j of with literals 1 j , 2 j , 3 j , the graph G contains a clause gadget G(C j ) with the following vertices and edges: • three vertices 1 j , 2 j , and 3 j , . . , G(C m ) plus the following vertices and edges, which ensure the required connections between the variable and clause gadgets: We will show below that there is always a solution that is entirely contained in U , which implies that the hardness result holds for D ∈ {U , V (G)}, and hence all versions of the fracture backdoor set problem, i.e., BD, V-BD, and C-BD, are NP-complete. Note that the reduction can be computed in polynomial time and it remains to show the equivalence between the two instances.
Towards showing the forward direction, assume that α : {x 1 , . . . , x n } → {0, 1} is a satisfying assignment for . Because α satisfies it follows that for every clause C j with literals 1 j , 2 j , and 3 is satisfied by α. We claim that the set B defined by: Hence in total C contains exactly k vertices as required. Now consider a component C that contains at least one vertex from a clause gadget G(C j ) for some j with 1 ≤ j ≤ m. Then |G(C j ) ∩ B| = 2 and moreover B contains all but exactly one literal vertex say a j for some a ∈ {1, 2, 3} from G(C j ). W.l.o.g. let x i be the literal of C j corresponding to a j .
Hence we can assume that B ⊆ U . We show next that B contains at least one of x i and x i from every variable gadget G(x i ). Suppose not and consider the component C of G \ B containing x i . Because B ⊆ U , we obtain that C contains all k − 3 vertices in G(x i ) and additionally at least the 8 vertices adjacent to x i and x i . Hence |C| ≥ k − 3 + 8 > k a contradiction to our assumption that B is a solution.
We show next that B contains at least two of and additionally the at least four vertices adjacent to the (at least two) literal vertices in { 1 j , 2 j , 3 j } \ B. Hence |C| ≥ k − 1 + 4 > k a contradiction to our assumption that B is a solution.
Hence B contains at least one vertex for every variable of and at least two vertices for every clause of . Moreover, because B is a solution it holds that |B| ≤ k = n + 2m. Hence |B| = n + 2m and B contains exactly one vertex from every variable gadget and exactly two vertices from every clause gadget. We claim that the assignment α with α(x i ) = 1 if and only if x i ∈ B is a satisfying assignment for . Suppose not and let C j be a clause of that is not satisfied by and let a j be the (unique) literal vertex of G(C j ) that is not in B. Consider the component C of G \ B that contains a j and assume w.l.o.g. that a j = x i for some i with 1 ≤ i ≤ n. Because α does not satisfy C j , we obtain that x i / ∈ B. Because furthermore B ⊆ U we obtain that C contains all of the k − 3 + 1 = k − 2 vertices in G(C j ) \ B and additionally at least the two vertices adjacent to a j as well as the vertex x i . Hence in total C contains at least k − 2 + 3 > k vertices, a contradiction to our assumption that B is a solution.
Even though BD is NP-complete, here we provide two efficient algorithms for solving it: we show that the problem is fixed-parameter tractable parameterized by k and can be approximated in polynomial time within a factor of k. Both of these algorithms are based on the observation that any backdoor has to contain at least one vertex from every connected subgraph of the instance of size k + 1. Proof. Because of the equivalence of the problems BD, V-BD, and C-BD with the FVD problem, it is sufficient to show the result for FVD.
We will show the theorem by providing a depth-bounded search tree algorithm for any instance I = G, D, k of FVD, which is based on the following observations. O1 If G is not connected then a solution for I can be obtained as the disjoint union of solutions for every component of G.
O2 If G is connected and C is any set of k + 1 vertices of G such that G[C ] is connected, then any solution for I has to contain at least one vertex from C .
These observations lead directly to the following recursive algorithm that given an instance I = G, D, k of FVD either determines that the instance is a No-instance or outputs a solution B ⊆ D of minimal size for I . The algorithm also remembers the maximum size of any component in a global constant c, which is set to k for the whole duration of the algorithm. The algorithm first checks whether G is connected. If G is not connected the algorithm calls itself recursively on the instance If G is connected and |V (G)| ≤ c, the algorithm returns the empty set as a solution. Otherwise, i.e. if G is connected but |V (G)| > c the algorithm first computes a set C of c + 1 vertices of G such that G[C ] is connected. This can for instance be achieved by a depth-first search that starts at any vertex of G and stops as soon as c + 1 vertices have been visited. If C ∩ D = ∅ then the algorithm returns No. Otherwise the algorithm branches on the vertices in C ∩ D, i.e., for every v ∈ C ∩ D the algorithm recursively computes a solution for the instance (G \ {v}, k − 1). It then returns the solution of minimum size returned by any of those recursive calls, or No-if none of those calls return a solution. This completes the description of the algorithm. The correctness of the algorithm follows immediately from the above observations. Moreover the running time of the algorithm is easily seen to be dominated by the maximum time required for the case that at each step of the algorithm G is connected. In this case the running time can be obtained as the product of the number of branching steps times the time spent on each of those. Because at each recursive call the parameter k is decreased by at least one and the number of branching choices is at most c + 1, we obtain that there are at most (c + 1) k = (k + 1) k branching steps. Furthermore, the time at each branching step is dominated by the time required to check whether G is connected, which is linear in the number of edges of G. Putting everything together, we obtain O((k + 1) k |E(G)|) as the total time required by the algorithm, which completes the proof of the lemma.
We note that the depth-first search algorithm in the above proof can be easily transformed into a polynomial-time approximation algorithm for BD and its variants that exhibits an approximation ratio of k + 1. In particular, instead of branching on the vertices of a connected subgraph C of G with k + 1 vertices, this algorithm would simply add all the vertices of C into the current solution. This way we obtain: Theorem 9. BD, V-BD, and C-BD can be approximated in polynomial time within a factor of k + 1.

The case of bounded coefficients
The goal of this section is to obtain the algorithmic results presented on the first row of Table 1. Recall that in this case we will be parameterizing also by c A , which is the maximum absolute coefficient occurring in A. Before we proceed to the results themselves, we first need to introduce a natural notion of "equivalence" among the components of an ILP instance.
Let Z be a backdoor to -compactness for an ILP instance I = (A, x, b, l, u, η) and let C be the set of connected components of I \ Z .
First note that switching two variables (that is switching two columns of A together with switching the corresponding entries in l, u, and η) results in an equivalent instance. Similarly, switching two constraints (that is switching two rows of A together with switching the corresponding entries in b) results in an equivalent instance as well. Therefore from now on, without loss of generality, we assume that we permuted the variables and constraints of I such that the variables of Z are the first at most |Z | variables of x, constraints of Z are the first at most |Z | constraints of I. Moreover, we assume that for a component C ∈ C, the variables of C form a consecutive block in x and the constraints of C form a block of consecutive rows of A. Now for a component C ∈ C, we define a triple of matrices (Q V C , Q C C , Q C ) (w.r.t. I and Z ) as follows (see also Fig. 3).
• The matrix Q V C is A F (C),var(Z ) , i.e., the part of constraints in C dealing with variables in Z , ,var(C) , i.e., the part of the constraints in Z dealing with var(C ), and • the matrix Q C is A F (C),var(C) , i.e., the part of constraints in C dealing with var(C ).
Observe that the matrices Q V C , Q C C , and Q C are precisely the submatrices of the constraint matrix of I that can contain nonzero coefficients for an element in C . In other words, this totally decomposes all constraints and variables contained in C as all coefficient for other variables are 0 and variables of C cannot appear in other components.
We define the equivalence relation ∼ Z on the components of I \ Z as follows: two components C 1 and C 2 are equivalent It is obvious that relation ∼ Z is an equivalence. We say that components C 1 and C 2 have the same type if C 1 ∼ Z C 2 . Proof. Let Z be the backdoor witnessing p(I) and fix a component C of I \ Z , we will now bound the number of all possible triples of matrices (Q V C , Q C C , Q C ). In order to do this we denote by Hence the total number of coefficients in the three matrices is bounded by 2 . We finish the proof of the first part by observing that the number of possible coefficients is bounded by 2c A (I) + 1.
Since two components C 1 and C 2 have the same type iff (Q V , we only need to check 2p (I) 2 pairs of entries in these matrices whether they are the same.
The following theorem, is the main tool for our algorithms employing the fracture number. It shows that given a backdoor set Z to |Z |-compactness for an ILP instance I with matrix A, then there is an fpt-algorithm with parameter |Z | + c A that transforms I into an equivalent ILP instance that is the N-fold of a block matrix whose dimensions and coefficients can be bounded by a function of the parameter |Z | + c A . In other words, the theorem provides an fpt-reduction with parameter |Z | + c A transforming any ILP instance into a 4-block N-fold instance whose parameters, i.e., the dimensions and coefficients of the block matrix, can be bounded by a function of |Z | + c A .

I \ Z . There is an algorithm which runs in time O(n 2 (p(I) + 1)! + |I|) and computes a (r + u) × (s + t) matrix
That is T is the subset of the equivalence classes of ∼ Z that have a representative component in C. The multiplicity mult(T ) of type T ∈ T is the number of components in C having type T . We set N = max T ∈T mult(T ). The idea of the proof is to build the matrix A 1 from Z and matrices A 2 , A 3 , A 4 as representatives of the types in such a way that the resulting N-fold 4 block ILP is equivalent to the given ILP instance I.
The matrix A 1 is simply the submatrix of Z that is the part of global constraints of A containing var(Z ) only.

Claim 1.
There is an ILP instance Î that is equivalent to ILP instance Ī with multˆI(T ) = N for all T ∈ TˆI. Moreover, cˆI = c¯I and the sizes of the matrices Q V , Q C , and Q for a type T ∈ TˆI can only double with respect to sizes of these matrices for a type in T .
After obtaining the equivalent instance Î computed by Claim 1, we put all possible matrices on a diagonal of the relevant matrix A 4 , next to each other in the matrix A 2 , and under each other in the matrix A 3 . That is we set A 2 to horizontal concatenation of all (Q C T ) T ∈T , A 3 to vertical concatenation of (Q V T ) T ∈T , and finally A 4 has matrices (Q T ) T ∈T on its diagonal.
The bound on size of the matrix A follows from Lemma 10 and Claim 1. The rest of the proof of the theorem is devoted to the proof of Claim 1.
Proof of Claim 1. The idea here is to take a type with less representatives and add a new one as a copy of a previous one. But this has to be done carefully in order to maintain equivalence of intermediate ILPs.
For the local part we start by observing that if we add a copy of some previous component, then the set of solutions for these two components is the same. However, as these components also interact with the global constraints we would like to have to restrict the set of solutions of the newly added component to all 0 solution only. Note that this cannot be done using lower and upper bounds only as the former set of solutions does not have to contain such a solution. That is, the (optimal) setting of global variables together with setting all component local variables to 0 can violate the right-hand side. In order to achieve the claim, we extend the matrices we have obtained from the component C in the following way. Let C be of type We denote the former C -variables as x C and the new C -variables as x C . We say that the extension is of Note that with this we have only doubled the number of local variable of component C .

Subclaim 1. Let I be an ILP instance and let T be a type of I. Denote I T →T the ILP instance I where components of type T are replaced with components of T of the first kind. Then, there is a bijection between solutions of ILP instances I and I T →T .
Proof of Subclaim 1. Note that it holds that x C = 0 for every component C of type T . Now a solution for I T →T has a natural projection to a solution of I (forget all x C variables). Furthermore, a solution for I can be extended to a solution of I T →T by setting x C = 0 for each component C of type T . This yields a bijection between the solution sets.
We say that a component C is extended if it has been created by the extension of the first kind. We transform all components with multiplicity less than N to extended components and denote I E the resulting ILP instance. Note that by Subclaim 1 the ILP instances I and I E are in equivalent.

Subclaim 2. Let I be an ILP instance, let C be a component of I, and let C be an extension of C of the second kind. Denote I the ILP
instance I with C added (i.e., it has one more component) then instances I and I are equivalent.

Proof of Subclaim 2. First we argue that I does have a solution if and only if I does.
To see this take a solution x of I and let x C be the part of x corresponding to C -variables. We build a solution to I follows. We copy the solution of every variable but the variables of C . We set variables x C = 0 and x C = x C .
Note that by this we have actually build a natural correspondence between the set of solutions to I and the set of solutions to I . Observe that this correspondence is not one-to-one as in general there can be more possibilities how to extend the solution to variables x C . We say that all these solutions project to the same solution x to instance I. However, as all the C -variables do not occur in the objective function the value of the objective function of all solutions that project to x is the same.
By combining the two claims it is possible to transform ILP instance I to Î with the following properties.
• all components of Î are either extended or for their type T it holds that mult I (T ) = N, • for each type T of Î it holds that multˆI(T ) = N, • p(Î) = p(I), • number of variables in the extended components of Î are doubled with respect to the component in I and the components that are not extended are also components of I.
Having proved Claim 1, the proof of the theorem is complete (see earlier discussion).
Note that the above Theorem together with Theorems 5, 6 and 8 now allows us to solve a given ILP instance I as follows.
We first compute a backdoor set Z witnessing p(I) (also p V (I) or p C (I)) using Theorem 8. We then use Theorem 11 to compute the 4-block N-fold instance I in fpt-time with parameter c A (I) + p(I). Finally, using Theorem 5 we can solve I in fpt-time with parameter c A (I) + p(I) using the fact that the coefficients and dimensions of the block matrix of I are bounded by a function of c A (I) + p(I). Therefore, we obtain the following corollary. Observe that because of condition (P2) in Theorem 11 (in particular the conditions that r ≤ |Z \ var(Z )| and s ≤ |var(Z )|), it follows that if Z is backdoor set witnessing p C (I) (or p V (I)), then the instance I obtained from Theorem 11 is a N-fold (2stage stochastic) ILP instance. Therefore, the same approach together with the fpt-tractability of n-fold and 2-stage stochastic ILP given in Theorem 6 allows us to obtain: Corollary 13. ILP is fpt when parameterized by max{c A , p V } and also when parameterized by max{c A , p C }.

Unary ILP
Here we will prove that Unary ILP is polynomial-time solvable when p C is bounded by a constant; this contrasts the case of general ILP, which remains NP-hard in this case (see Theorem 23 later). In particular, we will give an XP algorithm for Unary ILP parameterized by p C . We will also present lower bounds showing that such an algorithm cannot exist for Unary ILP parameterized by p V or p, and rule out the existence of a fixed-parameter algorithm for p C .

The algorithm
The crucial, and also most technically demanding, part of this result is showing that it suffices to restrict our search space to assignments over polynomially bounded variable domains.
Before showing this we need some preparation.

Proposition 14. Let A be an integer k × k non-singular matrix and b an integer vector. Then
Proof. Because of Proposition 2 it holds that . Moreover, since A is a non-singular integer matrix, we have that | det(A)| ≥ 1 and thus |x[i]| ≤ | det(A(i))|, which together with Proposition 1 implies |x Proof. Let y be y restricted to the variables in var(y) \ V and let J be the set of all columns of Q that are not in I . We will now apply the assignment β for the variables in y to Q. This will give us a set of equations that need to be satisfied for the variables in V allowing us to obtain a bound on β for these variables. Namely, the right-hand side denoted by d of our equations is obtained from d by subtracting the application of β to Q ( * , J ) , i.e., d = d − Q ( * , J ) β(y ), which after restricting Q to the columns I and using the restriction y of y to the variables in V gives us the following equations that are satisfied by β: Note that because I is a set of k linearly independent columns the matrix Q ( * ,I) is non-singular. Moreover, observe that The following lemma provides an important ingredient for Lemma 18 below. Its proof crucially makes use of the specific structure of our ILP instance.

Lemma 16. Let I be an instance of Unary ILP with matrix A. Then for any set D of linearly dependent columns of A, it holds that A ( * ,D)
contains a subset of at most p C (I)(p C (I) + 1) linearly dependent columns.
Proof. Let Z ⊆ F (I) be a constraint backdoor for I of size at most p C (I) and let s be a non-zero vector satisfying A ( * ,D) s = 0. Let C 1 , . . . , C p be all components of I \ Z that contain at least one variable corresponding to a column in D and let D i be the set of all columns in D that correspond to variables in C i . Moreover, let s C i be the restriction of s to the entries corresponding to variables in C i . Note that if p ≤ p C (I) + 1, then D already contains at most p C (I)(p C (I) + 1) linearly dependent columns and the lemma follows. So we can assume in the following that p > p C (I) + 1. Denote by w C i the vector A ( * ,D i ) s C i . If w C i = 0, then the variables in C i that s does not assign to 0 correspond to at most p C (I) linearly dependent columns and the lemma follows. Otherwise, it is easy to observe that if w C i [ j] = 0 then j corresponds to a constraint in Z . Hence for every C i all non-zero entries of the vector w C i correspond to constraints in Z . Consequently any subset of p C (I) + 1 vectors from w C 1 , . . . , w C p in particular the vectors w C 1 , . . . , w C p C (I)+1 are linearly dependent (since all their non-zero entries correspond to constraints in Z and |Z | ≤ p C (I)), which implies that the set 1≤i≤p C (I)+1 D i is the required subset of at most p C (I)(p C (I) + 1) linearly dependent columns of A ( * ,D) . I = (A, x, b, l, u, η) be an ILP instance, α a solution for I, and δ a non-zero integer vector such that α + δ and α − δ are feasible assignments for I. Then ηδ = 0 and moreover α + δ and α − δ are also solutions for I.
We are now ready to show that we only need to consider solutions with polynomially bounded variable domain. Proof. Let I = (A, x, b, l, u, η) be the provided instance of Unary ILP and let Z ⊆ F (I) be a constraint backdoor witnessing p C (I).
For a solution α of I, let V (α) be the set of all variables v of I such that |α(v)| ≥ 2m S . Let us now consider a solution α which minimizes the size of V (α). Observe that because m L ≥ 2m S it holds that if |V (α)| = 0 then the lemma holds, and so we may assume that V (α) is non-empty.
In the following we consider the submatrix B = A ( * ,V (α)) . Let us first consider the case where the columns of B are linearly dependent. We show that in this case, we can find a solution α such that |V (α )| < |V (α)|, which contradicts the choice of α.
Because of Lemma 16 there is a non-empty set O of linearly dependent columns of B of size at most p C (I)(p C (I) + 1). Consider a subset Y = {v 1 , . . . , v |Y | } of linearly dependent columns of O such that the columns of each proper subset of Y are linearly independent and let X = Y \ {v |Y | }. Because Y is a minimal set of linearly dependent columns, it holds that there is a vector a without any zero entries such that B ( * ,Y ) a = 0, which implies the existence of a vector a X , again without zero entries, such that B ( * ,X) a X = v |Y | . We will show that there is such a vector a that is integer and satisfies |a[i]| ≤ m S for every 1 ≤ i ≤ |Y |. We start by solving B ( * ,X) a X = v |Y | using Cramer's rule. Because the columns in X are linearly independent, it follows that B ( * ,X) has a set R of linearly independent rows with |R| = |X|. Then because the matrix B (R,X) is non-singular, we have that there is a unique a X such that R denotes the restriction of the vector v |Y | to the entries associated with the columns in R. Moreover, because there is a non-zero vector a X with ,X) ) is a non-zero integer vector that satisfies B ( * ,Y ) d = 0. From Proposition 1, we obtain that For notational convenience we will in the following assume that A starts with the columns v 1 , . . . , v |Y | from Y . Let w be the vector defined by: Note that Aw = 0. For an integer , let α : var(I) → Z denote the assignment α = α + w. Note that α is an integral assignment, moreover because it follows that α is a feasible integral assignment for Ax = b for every ∈ Z. Let be the integer with smallest absolute value such that there is at least one variable v ∈ V (α) with |α (v)| ≤ 2m S . We claim that for every |δ| ≤ | |, α δ is a solution for I.
We conclude that the columns of B must be linearly independent, which implies that there is a set R of |V (α)| linearly independent rows in B. Consider the set S of all components of I \ Z that have a non-empty intersection with either V (α) or the constraints corresponding to the rows in R. Let C 1 , . . . , C p be the restrictions of the components in S to the variables in V (α) and the constraints in R.
Observe that for every component C i , it holds that the rows in R that correspond to constraints in C i are zero everywhere but at the entries corresponding to variables in C i . Because the rows in R are independent it follows that every component must have at least as many variables as constraints. Moreover, because B (R, * ) is a square matrix and the only rows in R that do not correspond to constraints in components, correspond to the constraints in Z , we obtain that there are at most |Z | ≤ p C (I) components that have strictly more variables than constraints, all other components have the same number of rows and columns. Let C i be a component with the same number of rows as columns and let C i be the unique component and y be the subvector of x restricted to the variables of C i , d be the subvector of b restricted to entries that correspond to the constraints of C i , V = var(C i ), I the set of columns of Q corresponding to the variables in V , and β the assignment α restricted to the variables in y. Because the rows in Q are independent its rank is |F (C i )|, because α satisfies Aα(x) = b and all but the columns corresponding to the variables in var(C i ) of A * ,F (C i ) are zero everywhere, it holds that Qβ(y) = d. Hence we can apply Lemma 15 for Q, y, d, V , I , and β and obtain: for every variable v ∈ V . The second to last inequality follows because |α(v)| ≤ 2m S for every v in var(C i ) \ var(C i ), which is because (var(C i ) \ var(C i )) ⊆ (var(I) \ V (α)). This shows that the assignment α is bounded by m M for all variables contained in components C i that have the same number of variables and constraints. Consider the remaining components D 1 , . . . , D s among C 1 , . . . , C p , i.e., the components among C 1 , . . . , C p that have more variables than constraints. Recall that s ≤ |Z | ≤ p C (I). Let V = 1≤i≤s var(D i ) and let J be the corresponding columns of V in A. Note that | J | ≤ (p C (I)) 2 . Because V ⊆ V (α) it holds that J is a set of linearly independent columns. Hence there is a set R of | J | linearly independent rows in A ( * , J ) .
Let Q = A (R , * ) , y = x, d be the subvector of b restricted to entries that correspond to the rows in R , I be the columns in J restricted to the rows in R , and β = α. Because the rows in Q are independent its rank is |I|, because Q is a submatrix of A only restricted in rows, we have Qβ(y) = d. Hence we can apply Lemma 15 for Q, y, d, V , I , and β and obtain: It follows from Lemma 18 that I and I are equivalent ILP instances. Now let ω be the incidence treewidth of I (which is equal to the incidence treewidth of I). Observe that ω ≤ p C (I) and hence it follows from Proposition 19 that I (and thus also I) can be solved in time O((c A · m L · |var(I)|) p C (I) )(|var(I)| + |F (I)|).

Lower bounds
We complement our algorithm with matching lower bounds: strong NP-hardness for variable and mixed backdoors, W[1]-hardness in the case of constraint backdoors, and weak NP-hardness for constraint and mixed backdoors.
The following theorem can be obtained from the proof of [20,Theorem 12], which showed that Unary ILP is pNP-hard parameterized by the treedepth of the primal graph. However, since the definition of ILPs is different in that work, we include the reduction adjusted to our setting to have a self-contained proof.
Proof. We prove the theorem by a polynomial-time reduction from the well-known NP-hard 3-Colorability problem [23]: given a graph, decide whether the vertices of G can be colored with three colors such that no two adjacent vertices of G share the same color.
The main idea behind the reduction is to represent a 3-partition of the vertex set of G by the domain values of three "global" variables. The value of each of these global variables will represent a subset of vertices of G that will be colored using the same color. To represent a subset of the vertices of G in terms of domain values of the global variables, we will associate every vertex of G with a unique prime number and represent a subset by the value obtained from the multiplication of all prime numbers of vertices contained in the subset. To ensure that the subsets represented by the global variables correspond to a valid 3-partition of G we will introduce constraints which ensure that: C1 For every prime number representing some vertex of G exactly one of the global variables is divisible by that prime number. This ensures that every vertex of G is assigned to exactly one color class. Note that the variables sl 1 i, j , sl 2 i, j , sl 3 e,i, j , sl 4 e,i, j , and sl 5 e,i are so-called "Slack" variables, whose sole purpose is to obtain an ILP instance that is in equation normal form. The instance I has the following constraints (in the following let α be any feasible assignment of I): • domain restrictions for all variables as given above, i.e.: -for every i and j with 1 ≤ i ≤ |V (G)| and 1 ≤ j ≤ 3, the constraints c j ≥ 0, m i, j ≥ 0, sl 1 i, j ≥ 0, sl 2 i, j ≥ 0, 0 ≤ r i, j ≤ p(i) − 1, and 0 ≤ u i, j ≤ 1.
-Constraints that ensure that α(u i, j ) = 0 if and only if α(r i, j ) = 0, i.e., the constraints u i, j + sl 1 i, j = r i, j and r i, j + sl 2 i, j = (p(i) − 1)u i, j . Note that together the above constraints now ensure that α(u i, j ) = 0 if and only if α(c j ) is divisible by p(i).
-Constraints that ensure that exactly one of α(u i,1 ), α(u i,2 ), and α(u i, 3 ) is equal to 0, i.e., the constraints u i,1 + u i,2 + u i,3 = 2. Note that together all the above constraints now ensure condition C1 holds. • The following constraints, introduced for each 1 ≤ j ≤ 3, together guarantee that condition C2 holds: -Constraints that ensure that for every e ∈ E(G) and i ∈ e, it holds that α(r e,i, j ) is equal to the remainder of α(c j ) divided by p(i), i.e., the constraint c j = p(i)m e,i, j + r e,i, j .
-Constraints that ensure that for every e ∈ E(G), i ∈ e, and j with 1 ≤ j ≤ 3 it holds that α(u e,i, j ) = 0 if and only if α(r e,i, j ) = 0, i.e., the constraints u e,i, j + sl 3 e,i, j = r e,i, j and r e,i, j + sl 4 e,i, j = (p(i) − 1)u e,i, j . Note that together the above constraints now ensure that α(u e,i, j ) = 0 if and only if α(c j ) is divisible by p(i). -Constraints that ensure that for every e = {i, k} ∈ E(G) and j with 1 ≤ j ≤ 3 it holds that at least one of α(u e,i, j ) and α(u e,k, j ) is non-zero, i.e., the constraint u e,i, j + u e,k, j − sl 5 e, j = 1. Note that together with all of the above constraints this now ensures condition C2.
This completes the construction of I. Clearly I can be constructed in polynomial time, and the largest coefficient used by I is equal to p(|V (G)|). It is well-known that p(i) is upper-bounded by O (i log i) due to the Prime Number Theorem, and so this in particular implies that the numbers which occur in I are bounded by a polynomial in |V (G)|.
Following the construction and explanations provided above, it is not difficult to see that I has a feasible assignment if and only if G has a 3-coloring. Indeed, for any 3-coloring of G, one can construct a feasible assignment of I by computing the prime-number encoding for vertices that receive colors 1, 2, 3 and assign these three numbers to c 1 , c 2 , c 3 , respectively.
Such an assignment allows us to straightforwardly satisfy the constraints ensuring C1 holds (since each prime occurs in exactly one global constraint), the constraints ensuring C2 holds (since each edge is incident to at most one of each color) while maintaining the domain bounds.
On the other hand, for any feasible assignment α, clearly each of α(c 1 ), α(c 2 ), α(c 3 ) will be divisible by some subset of prime numbers between 2 and p(|V (G)|). In particular, since α is feasible it follows from the construction of our first group of constraints that each prime between 2 and p(|V (G)|) divides precisely one of α(c 1 ), α(c 2 ), α(c 3 ), and so this uniquely encodes a corresponding candidate 3-coloring for the vertices of the graph. Finally, since α also satisfies the second group of constraints, this candidate 3-coloring must have the property that each edge is incident to at exactly 2 colors, and so it is in fact a valid 3-coloring. • for every e = {w, v} ∈ E(G) and j with 1 ≤ j ≤ 3, one component on the vertices m e,w, j , m e,v, j , sl 3 e,w, j , sl 4 e,v, j , r e,w, j , r e,v, j , u e,w, j , u e,v, j , and sl 5 e, j . Moreover, these 9 variables occur in exactly 7 constraints together; these are the constraints introduced above to ensure condition C2. Hence the total size of these components is 16. This shows that B is a variable backdoor to 25-compactness, as required.
The following theorem can also be obtained from the W[1]-hardness of Unary n-fold ILP parameterized only by the dimensions (but not the coefficients) of the matrix, which is shown in [34, Lemma 5.1] using a reduction from Unary Bin Packing. We provide a different reduction here and adjust the proof to our setting for self-containment.

Theorem 22. Unary ILP-feasibility is W [1]-hard parameterized by p C (I).
Proof. We prove the theorem by a parameterized reduction from Multicolored Clique, which is well-known to be W[1]complete [41]. Given an integer k and a k-partite graph G with partition V 1 , . . . , V k , the Multicolored Clique problem ask whether G contains a k-clique. In the following we denote by E i, j the set of all edges in G with one endpoint in V i and the other endpoint in V j , for every i and j with 1 ≤ i < j ≤ k. To show the theorem, we will construct an instance I of ILP-feasibility in polynomial time that has a constraint backdoor set of size 2k + 2 k 2 to 3-compactness and coefficients bounded by a polynomial in |V (G)| such that G has a k-clique if and only if I has a feasible assignment.
The main idea behind the reduction is to first guess one vertex from each part V i and one edge between every two parts V i and V j and to then verify that the selected vertices and edges form a k-clique in G.
The first step is achieved by introducing one binary variable for every vertex and edge of G together with 2k + 2 k 2 global constraints that ensure that (1) exactly one of the variables representing the vertices in V i is set to one and (2) exactly one of the variables representing the edges between V i and V j is set to one. The second step, i.e., verifying that the chosen vertices and edges indeed form a k-clique of G, is achieved by identifying each vertex of G with a unique number such that the sum of any two numbers assigned to two vertices of G is unique. By identifying each edge of G with the sum of the numbers assigned to its endpoints, it is then possible to verify that the selected vertices and edges form a k-clique by checking whether the number assigned to the selected edge e is equal to the sum of the numbers assigned to the selected vertices in V i and V j . Sets of numbers for which the sum of every two numbers from the set is unique are also known as Sidon sequences. Indeed a Sidon sequence is a sequence of natural numbers such that the sum of every two distinct numbers in the sequence is unique. For our reduction we will need a Sidon sequence of |V (G)| natural numbers, i.e., containing one number for each vertex of G. Since the numbers in the Sidon sequence will be used as coefficients of I, we need to ensure that the largest of these numbers is bounded by a polynomial in G. Indeed [15] shows that a Sidon sequence containing n elements and whose largest element is at most 2p 2 , where p is the smallest prime number larger or equal to n can be constructed in polynomial time. Together with Bertrand's postulate [1], which states that for every natural number n there is a prime number between n and 2n, we obtain that a Sidon sequence containing |V (G)| numbers and whose largest element is at most 8|V (G)| 2 can be found in polynomial time. In the following we will assume that we are given such a Sidon sequence S and we denote by S(i) the i-th element of S for any i with 1 ≤ i ≤ |V (G)|. Moreover, we denote by max(S) and max 2 (S) the largest element of S respectively the maximum sum of any two numbers in S.
We are now ready to construct the instance I of ILP-feasibility such that G has a k-clique if and only if I has a feasible assignment. This instance I has the following variables: • For every e ∈ E(G) a binary variable e (with domain {0, 1}) that is 1 if e is selected to be in the k-clique and 0 otherwise. • For every i with 1 ≤ i ≤ k, a variable v i (with unrestricted domain), which will be set to S(v) if the vertex v ∈ V i was selected to be in the k-clique.
• For every i and j with 1 ≤ i < j ≤ k, a variable e i, j (with unrestricted domain), which will be set to S(v) + S(u) if the edge e ∈ E i, j with e = {u, v} was selected to be in the k-clique.
I has the following constraints: • Constraints that restrict the domains of all variables as specified above, i.e.: -for every v ∈ V (G), the constraints 0 ≤ v ≤ 1.
We will denote by D the set of all these constraints.
• for every i with 1 ≤ i ≤ k, the constraint v∈V i v = 1, which ensures that from every part V i exactly one vertex is selected to be in the k-clique. We will denote by V SEL the set of all these constraints.
• for every i and j with 1 ≤ i < j ≤ k, the constraint e∈E i, j e = 1, which ensures that between any two parts V i and V j exactly one edge is selected to be in the k-clique. We will denote by E SEL the set of all these constraints.
• for every i with 1 ≤ i ≤ k, the constraint v∈V i S(v)v = v i , which ensures that v i is equal to S(v) whenever v is selected for the k-clique. We will denote by V ASS the set of all these constraints.
• for every i and j with 1 ≤ i < j ≤ k, the constraint e={u,v}∈E i, j (S(u) + S(v))e = e i, j , which ensures that e i, j is equal to S(u) + S(v) whenever the edge e ∈ E i, j with endpoints u and v is selected for the k-clique. We will denote by E ASS the set of all these constraints.
• for every i and j with 1 ≤ i < j ≤ k, the constraint v i + v j = e i, j , which ensures that between any two parts V i and V j the vertices selected for the clique are equal to the endpoints of the edge chosen between the two parts. We will denote by VE CHECK the set of all these constraints.
This completes the construction of I. Clearly I can be constructed in polynomial time, and the largest coefficient used by I is equal to max 2 (S), which is at most 2 max(S) ≤ 16|V (G)| 2 . We first show that I has a small constraint backdoor to 3-compactness, and hence our parameter can bounded in terms of k. Namely, we claim that the set B = V SEL ∪ E SEL ∪ V ASS ∪ E ASS ∪ VE CHECK of constraints of I is a constraint backdoor of size at most 2k + 3 k 2 to 3-compactness. Clearly, the components of G I \ B have size at most 3, i.e., G I has one component of size one for every variable in {v 1 , . . . , v k , e 1,2 , . . . , e k−1,k } as well as one component of size 3 for every a ∈ V (G) ∪ E(G), containing the variable a together with the two constrains 0 ≤ a and a ≤ 1. Moreover, the sets V SEL , E SEL , V ASS , E ASS , and VE CHECK have sizes at most k, k 2 , k, k 2 , and k 2 , respectively, which implies that |B| ≤ 2k + 3 k 2 . It remains to show that G has k-clique if and only if I is feasible. For the forward direction suppose that G has a k-clique on the vertices c 1 , . . . , c k , where c i ∈ V i for every i with 1 ≤ i ≤ k. Then it is straightforward to verify that the assignment α with: • α(c i ) = 1 for every i with 1 ≤ i ≤ k and α(v) = 0 for every v ∈ V (G) \ {c 1 , . . . , c k }, • α({c i , c j }) = 1 for every i and j with 1 ≤ i < j ≤ k and α(e) = 0 for every e ∈ E(G) \ {c i , c j } : 1 ≤ i < j ≤ k , • α(v i ) = S(c i ) for every i with 1 ≤ i ≤ k, and • α(e i, j ) = S(c i ) + S(c j ) for every i and j with 1 ≤ i < j ≤ k is a feasible assignment for I.
For the reverse direction suppose that we are given a feasible assignment α for I. Then because α satisfies the constraints in D ∪ V SEL ∪ E SEL we obtain that for every i and j with 1 ≤ i < j ≤ k it holds that exactly one of the variables in V i and exactly one of the variables in E i, j is set to one. Let c i denote the unique vertex in V i with α(c i ) = 1 and similarly let d i, j denote the unique edge in E i, j with α(d i, j ) = 1. It follows from the constraints in V ASS that α(v i ) = S(c i ) and similarly using the constraints in E ASS we obtain that α(e i, j ) = S(u) + S(v), where u and v are the endpoints of the edge d i, j in G. Moreover, we obtain from the constraints in VE CHECK that v i + v j = e i, j and hence S(c i ) + S(c j ) = S(u) + S(v), where again u and v are the endpoints of the edge d i, j in G. Because S is a Sidon sequence, it follows that this can only hold if S(c i ) = S(u) and S(c j ) = S(v), which implies that c i = u and c j = v. This shows that the endpoints of the selected edges d 1,2 , . . . , d k−1,k are the vertices in c 1 , . . . , c k and hence G[{c 1 , . . . , c k }] is a k-clique of G. Theorem 23. ILP is NP-hard even if p C = 1.
Proof. We show the result by a polynomial reduction from the Subset Sum problem, which is well-known to be weakly NP-complete. Given a set S := {s 1 , . . . , s n } of integers and an integer s, the Subset Sum problem asks whether there is a subset S ⊆ S such that s∈S s = s. Let I := (S, s) with S := {s 1 , . . . , s n } be an instance of Subset Sum. We will construct an equivalent ILP instance I with p C (I) = 1 in polynomial time as follows. The instance I has n binary variables x 1 , . . . , x n and apart from the domain constraints for these variables only one global constraint defined by 1≤i≤n s i x i = s. Because I has only one constraint, it holds that p C (I) = 1 and moreover it is straightforward to verify that I is equivalent to (S, s) (this has also for instance been shown in [30,Theorem 1]).
At the end of this section we prove that ILP parameterized by coefficients and a constraint or variable backdoor does not admit a polynomial kernel, unless NP ⊆ co-NP/poly. We use polynomial parameter transformations from two problems which do not admit a polynomial kernel.

Set Cover
Input: A universe U , a family F of subsets of U , k ∈ N. Parameter:

|U |.
Task: Find a subfamily F ⊆ F such that |F | = k and F cover U , i.e., F ∈F F = U .

Input:
A universe U , a family F of subsets of U . Parameter:

|U |.
Task: Find X ⊆ U such that X splits each set F ∈ F , i.e., F ∩ X = ∅ and F \ X = ∅. Theorem 24 ([6]). The problems Set Cover and Splitting Set do not admit a polynomial kernel, unless NP ⊆ co-NP/poly. Theorem 25. ILP-feasibility with 0 and 1 in the matrix, parameterized by b C 1 (I) and righthandside coefficients does not admit a polynomial kernel, unless NP ⊆ co-NP/poly. (U , F , k) be an instance of Set Cover. We formulate an ILP instance I with boolean variables x F ∈ {0, 1} for each family F ∈ F .

Proof. Let
The meaning of the variable x F is we put F in subfamily F if and only if x F = 1. Now, it is easy to see that I is feasible if and only if there is a subfamily F ⊆ F of size k which covers U . There are |U | + 1 constraints in the instance I, thus after removing them from the incidence graph G I we get a graph without edges. We use only 0 and 1 in the matrix. The righthandside is bounded by k. Note that if k ≥ |U |, then the instance of Set Cover is trivial. Therefore, we can assume that k ≤ |U |, i.e., it is bounded by the parameter. The proof of theorem follows from Theorem 24.
Theorem 26. ILP-feasibility with 0 and 1 in the matrix, parameterized by b V Proof. Let (U , F ) be an instance of Splitting Set. We formulate an ILP instance I with boolean variables y u ∈ {0, 1} for each element u ∈ U . 0 < u∈F y u < |F | ∀F ∈ F The meaning of the variable y u is that we put the element u into X if and only if y u = 1. Now, it is easy to see that the instance I is feasible if and only if there exists a set X ⊆ U such that X splits each set F ∈ F . There are |U | variables in the instance I, thus after removing them from the incidence graph G I we get a graph without edges. We use only 0 and 1 in the matrix and coefficients on the righthandside are bounded by max F ∈F |F | ≤ |U |. The proof of theorem follows from Theorem 24.

Concluding notes
In order to overcome the complexity barriers of ILP, a wide range of problems have been encoded in restricted variants of ILP such as 2-stage stochastic ILP and N-fold ILP; examples for the former include a range of transportation and logistic problems [42,29], while examples for the latter range from scheduling [33] to, e.g., computational social choice [34]. Our framework provides a unified platform which generalizes 2-stage stochastic ILP, N-fold ILP and also 4-block N-fold ILP. Moreover, it represents a natural measure of the complexity of ILPs which can be applied to any ILP instance, including those which lie outside of the scope of all previously known algorithmic frameworks. In fact, one may view our algorithmic results as "algorithmic meta-theorems" for ILP, where previously known algorithms for 2-stage stochastic ILP, N-fold ILP and 4-block N-fold ILP only represent a simple base case.
Our algorithms are complemented with matching lower bounds showing that the considered restrictions are, in fact, necessary in order to obtain fixed-parameter or XP algorithms. The only remaining blank part in the presented complexity map is the question of whether mixed fracture backdoors admit a fixed-parameter algorithm in case of bounded coefficients; we consider this a major open problem in the area. A first step towards settling this question would be to resolve the fixedparameter (in)tractability of 4-block N-fold ILP; progress in this direction seems to require new techniques and insights [27].

Declaration of competing interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.