Best-Case and Worst-Case Sparsifiability of Boolean CSPs

We continue the investigation of polynomial-time sparsification for NP-complete Boolean Constraint Satisfaction Problems (CSPs). The goal in sparsification is to reduce the number of constraints in a problem instance without changing the answer, such that a bound on the number of resulting constraints can be given in terms of the number of variables n. We investigate how the worst-case sparsification size depends on the types of constraints allowed in the problem formulation—the constraint language—and identify constraint languages giving the best-possible and worst-possible behavior for worst-case sparsifiability. Two algorithmic results are presented. The first result essentially shows that for any arity k, the only constraint type for which no nontrivial sparsification is possible has exactly one falsifying assignment, and corresponds to logical OR (up to negations). Our second result concerns linear sparsification, that is, a reduction to an equivalent instance with O(n)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(n)$$\end{document} constraints. Using linear algebra over rings of integers modulo prime powers, we give an elegant necessary and sufficient condition for a constraint type to be captured by a degree-1 polynomial over such a ring, which yields linear sparsifications. The combination of these algorithmic results allows us to prove two characterizations that capture the optimal sparsification sizes for a range of Boolean CSPs. For NP-complete Boolean CSPs whose constraints are symmetric (the satisfaction depends only on the number of 1 values in the assignment, not on their positions), we give a complete characterization of which constraint languages allow for a linear sparsification. For Boolean CSPs in which every constraint has arity at most three, we characterize the optimal size of sparsifications in terms of the largest OR that can be expressed by the constraint language.


Introduction Background
The framework of constraint satisfaction problems (CSPs) provides a unified way to study the computational complexity of a wide variety of combinatorial problems such as CNF-Satisfiability, Graph Coloring, and Not-All-Equal SAT.The framework uncovers algorithmic approaches that simultaneously apply to several problems, and also identifies common sources of intractability.For the purposes of this discussion, a CSP is specified using a (finite) constraint language, which is a set of (finite) relations; the problem is to decide the satisfiability of a set of constraints, where each constraint has a relation coming from the constraint language.The fact that many problems can be viewed as CSPs motivates the following investigation: how does the complexity of a CSP depend its constraint language?that, on the other hand, if a Boolean relation R is not balanced, then there does not exist a degree-1 polynomial over any ring that captures R in the sense required for application of the polynomial framework.The property of being balanced is (as defined) a universal-algebraic property; these results thus tightly bridge universal algebra and the polynomial framework.

Characterizations
The property of being balanced gives an easy way to prove that certain Boolean CSPs admit linear sparsifications.But perhaps more importantly, this characterization constructively exhibits a certain witness when a relation can not be captured by a degree-1 polynomial, in the form of the alternating sum of satisfying assignments that yield an unsatisfying assignment.In several scenarios, we can turn this witness structure against degree-1 polynomials into a lower bound proving that the problem does not have a linear sparsification.As a consequence, we can prove two fine-grained characterizations of sparsification complexity.
Characterization of symmetric CSPs with a linear sparsification (Section 5) We say that a Boolean relation is symmetric if the satisfaction of a constraint only depends on the number of 1-values taken by the variables (the weight of the assignment), but does not depend on the positions where these values appear.For example, "1-in-k"-constraints are symmetric, just as "not-all-equal"-constraints, but the relation R a→b = {(0, 0), (0, 1), (1, 1)} corresponding to the truth value of a → b is not.We prove that if a symmetric Boolean relation R is not balanced, then it can implement (Definition 2.7) a binary OR using constants and negations but without having to introduce fresh variables.Building on this, we prove that if such an unbalanced symmetric relation R occurs in a constraint language Γ for which CSP(Γ) is NP-complete, then CSP(Γ) does not admit a sparsification of size O(n 2−ε ) for any ε > 0. Consequently, we obtain a characterization of the sparsification complexity of NP-complete Boolean CSPs whose constraint language consists of symmetric relations: there is a linear sparsification if and only if the constraint language is balanced.This yields linear sparsifications in several new scenarios that were not known before.

Characterization of sparsification complexity for CSPs of low arity (Section 6)
By combining the linear sparsifications guaranteed by balanced constraint languages with the nontrivial sparsification when the largest-arity relations do not have exactly one falsifying assignment, we obtain an exact characterization of the optimal sparsification size for all Boolean CSPs where each relation has arity at most three.For a Boolean constraint language Γ consisting of relations of arity at most three, we characterize the sparsification complexity of Γ as an integer k ∈ {1, 2, 3} that represents the largest OR that Γ can implement using constants and negations, but without introducing fresh variables.Then we prove that CSP(Γ) has a sparsification of size O(n k ), but no sparsification of size O(n k−ε ) for any ε > 0, giving matching upper and lower bounds.Hence for all Boolean CSPs with constraints of arity at most three, the polynomial-based framework gives provably optimal sparsifications.

Preliminaries
For a positive integer n, define [n] := {1, 2, . . ., n}.For an integer q, we let Z/qZ denote the integers modulo q.These form a field if q is prime, and a ring otherwise.We will use x ≡ q y to denote that x and y are congruent modulo q, and x ≡ q y to denote that they are incongruent modulo q.For statements marked with a star ( ), the (full) proof can be found in Appendix A.

Parameterized complexity
Since a polynomial-time reduction to an equivalent sparse instance yields a generalized kernel, lower bounds against generalized kernels can be used to prove the non-existence of such sparsification algorithms.To relate the sparsifiability of different problems to each other, the following notion is useful.
It is well-known [1, 2] that the existence of a linear-parameter transformation from problem P to Q implies that any generalized kernelization lower bound for P, also holds for Q.

Operations, relations, and preservation
A Boolean operation is a mapping from {0, 1} k to {0, 1}, where k, a natural number, is said to be the arity of the operation; we assume throughout that operations have positive arity.From here, we define a partial Boolean operation in the usual way, that is, it is a mapping from a subset of {0, 1} k to {0, 1}.We say that a partial Boolean operation f of arity k is idempotent if f (0, . . ., 0) = 0 and f (1, . . ., 1) = 1; and, self-dual if for all (a 1 , . . ., a k ) ∈ {0, 1} k , when f (a 1 , . . ., a k ) is defined, it holds that f (¬a 1 , . . ., ¬a k ) is defined and f (a 1 , . . ., a k ) = ¬f (¬a 1 , . . ., ¬a k ).A constraint language over D is a finite set of relations over D; a Boolean constraint language is a constraint language over {0, 1}.For a Boolean constraint language Γ, we define CSP(Γ) as follows.
Input: A tuple (C, V ), where C is a finite set of constraints, V is a finite set of variables, and each constraint is a pair R(x 1 , . . ., x k ) for R ∈ Γ and x 1 , . . ., x k ∈ V .
Question: Does there exist a satisfying assignment, that is, an assignment f : Let f : {0, 1} k → {0, 1} be a partial Boolean operation, and let T ⊆ {0, 1} n be a Boolean relation.We say that T is preserved by f when, for any tuples t 1 = (t )) are defined, then this tuple is in T .We say that a Boolean constraint language Γ is preserved by f if each relation in Γ is preserved by f .We say that a Boolean relation is balanced if it is preserved by all balanced operations, and that a Boolean constraint language is balanced if each relation therein is balanced.

Proposition 2.4 ( ).
A Boolean relation R is balanced if and only if for all odd k ≥ 1, the relation R is preserved by the alternating operation of arity k.
We will use the following straightforwardly verified fact tacitly, throughout.
Observation 2.5.Each balanced operation is idempotent and self-dual.

Constraint Satisfaction and Definability
Assumption 2.6.By default, we assume in the sequel that the operations, relations, and constraint languages under discussion are Boolean, and that said operations and relations are of positive arity.We nonetheless sometimes describe them as being Boolean, for emphasis.
When Γ is a constraint language over D, we use Γ * to denote the expansion of Γ where each element of D appears as a relation, that is, we define Γ The following is a key property of cone-definability; it states that relations that are cone-definable from a constraint language Γ may be simulated by the constraint language, and thus used to prove hardness results for CSP(Γ).
Proposition 2.9 ( ).Suppose that Γ is an intractable constraint language, and that ∆ is a constraint language such that each relation in ∆ is cone-definable from a relation in Γ.Then, there exists a linear-parameter transformation from CSP(Γ * ∪ ∆) to CSP(Γ).

Trivial versus non-trivial sparsification
It is well known that k-CNF-SAT allows no non-trivial sparsification, for each k ≥ 3 [7].This means that we cannot efficiently reduce the number of clauses in such a formula to O(n k−ε ).
The k-or relation is special, in the sense that there is exactly one k-tuple that is not contained in the relation.We show in this section that when considering k-ary relations for which there is more than one k-tuple not contained in the relation, a non-trivial sparsification is always possible.In particular, the number of constraints of any input can efficiently be reduced to O(n k−1 ).Using Lemmas 3.4 and 3.6, we will completely classify the constraint languages that allow a non-trivial sparsification as follows.
Theorem 3.1 ( ).Let Γ be an intractable (Boolean) constraint language.Let k be the maximum arity of any relation R ∈ Γ.The following dichotomy holds. If To obtain the kernels given in this section, we will heavily rely on the following notion for representing constraints by polynomials.Definition 3.2.Let R be a k-ary Boolean relation.We say that a polynomial p u over a ring E u captures an unsatisfying assignment u ∈ {0, 1} k \ R with respect to R, if the following two conditions hold over E u .
The following Theorem is a generalization of Theorem 16 in [15].The main improvement is that we now allow the usage of different polynomials, over different rings, for each u / ∈ R. Previously, all polynomials had to be given over the same ring, and each constraint was captured by a single polynomial.
a prime power} and polynomial p u over E u of degree at most d that captures u with respect to R. Then there exists a polynomialtime algorithm that, given a set of constraints C over {R} over n variables, outputs

that any Boolean assignment satisfies all constraints in C if and only if it satisfies all constraints in C .
The next lemma states that any k-ary Boolean relation R with |R| < 2 k − 1 admits a non-trivial sparsification.To prove the lemma, we show that such relations can be represented by polynomials of degree at most k − 1, such that the sparsification can be obtained using Theorem 3.3.Since relations with |R| = 2 k have a sparsification of size O(1), as constraints over such relations are satisfied by any assignment, it will follow that k-ary relations with |{0, 1} k \ R| = 1 always allow a non-trivial sparsification.

Lemma 3.4 ( ).
Let R be a k-ary Boolean relation with |R| < 2 k − 1.Let C be a set of constraints over {R}, using n variables.Then there exists a polynomial-time algorithm that outputs C ⊆ C with |C | = O(n k−1 ), such that a Boolean assignment satisfies all constraints in C if and only if it satisfies all constraints in C.
Proof sketch.We will show that for every u ∈ {0, 1} k \ R, there exists a degree-(k − 1) polynomial p u over Q that captures u, such that the result follows from Theorem 3.3.We will prove the existence of such a polynomial by induction on k.For k = 1, the lemma statement implies that R = ∅.Thereby, for any u / ∈ R, we simply choose p u (x 1 ) := 1.This polynomial satisfies the requirements, and has degree 0. Let k > 1 and let u = (u 1 , We distinguish two cases, depending on whether u and w agree on some position. Suppose u i = w i for all i, and assume for concreteness that u = (0, . . ., 0) and w = (1, . . ., 1).Then the polynomial p and thereby p u (x 1 , . . ., x k ) = 0; the product has a 0-term.Other values of u and w are handled similarly.Now suppose u i = w i for some i ∈ [k], and assume for concreteness that and (w 2 , . . ., w k ) are distinct tuples not in R , by induction there is a polynomial p u of degree k − 2 that captures u with respect to R .Then the polynomial p u (x 1 , . . ., x k ) := x 1 • p u (x 2 , . . ., x k ) has degree k − 1 and captures u with respect to R.
To show the other part of the dichotomy, we will need the following theorem.
The next lemma formalizes the idea that any k-ary relation with |{0, 1} k \ R| = 1 is equivalent to k-or, up to negation of variables.The proof of the dichotomy given in Theorem 3.1 will follow from Lemma 3.4, together with the next lemma and Theorem 3.5.

4
From balanced operations to linear sparsification The main result of this section is the following theorem, which we prove below.
Theorem 4.1.Let Γ be a balanced (Boolean) constraint language.Then CSP(Γ) has a kernel with O(n) constraints that are a subset of the original constraints.The kernel can be stored using O(n log n) bits.
To prove the theorem, we will use two additional technical lemmas.To state them, we introduce some notions from linear algebra.Given a set S = {s 1 , . . ., s n } of k-ary vectors in Z k , we define span Z (S) as the set of all vectors y in Z k for which there exist α 1 , . . ., α n ∈ Z such that y = i∈[n] α i s i .Similarly, we define span q (S) as the set of all k-ary vectors y over Z/qZ, such that there exist α 1 , . . ., α n such that y ≡ q i∈[n] α i s i .For an m × n matrix S, we use s i for i ∈ [m] to denote the i'th row of S. Lemma 4.2 ( ).Let S be an m × n integer matrix.Let u ∈ Z n be a row vector.If u ∈ span q ({s 1 , . . ., s m }) for all prime powers q, then u ∈ span Z ({s 1 , . . ., s m }).

Lemma 4.3 ( ).
Let q be a prime power.Let A be an m × n matrix over Z/qZ.Suppose there exists no constant c ≡ q 0 for which the system Ax ≡ q b has a solution, where b := (0, . . ., 0, c) T is the vector with c on the last position and zeros in all other positions.
Using these tools from linear algebra, we now prove the main sparsification result.
Proof of Theorem 4.1.We show that for all relations R in the balanced constraint language Γ, for all u / ∈ R, there exists a linear polynomial p u over a ring E u ∈ {Z/q u Z | q u is a prime power} that captures u with respect to R. By applying Theorem 3.3 once for each relation R ∈ Γ, to reduce the number of constraints involving R to O(n), we then reduce any n-variable instance of CSP(Γ) to an equivalent one on Suppose for a contradiction that there exists R ∈ Γ and u / ∈ R, such that no prime power q and polynomial p over Z/qZ exist that satisfy conditions (1) and (2).We can view the process of finding such a linear polynomial, as solving a set of linear equations whose unknowns are the coefficients of the polynomial.We have a linear equation for each evaluation of the polynomial for which we want to enforce a certain value.
Let R = {r 1 , . . ., r }.By the non-existence of p and q, the system has no solution for any prime power q and c ≡ q 0. Otherwise, it is easy to verify that q is the desired prime power and p(x 1 , . . ., x k ) := α 0 + k i=1 α i x i is the desired polynomial.The fact that no solution exists, implies that (1, u 1 , . . ., u k ) is in the span of the remaining rows of the matrix, by Lemma 4.3.But this implies that for any prime power q, there exist coefficients β 1 , . . ., β over Z/qZ such that u ≡ q β i r i .Furthermore, since the first column of the matrix is the all-ones column, we obtain that β i ≡ q 1.By Lemma 4.2, it follows that there exist integer coefficients γ 1 , . . ., γ such that γ i = 1 and furthermore u = γ i r i .But it immediately follows that R ∈ Γ is not preserved by the balanced operation given by f (x 1 , . . ., x ) := γ i x i , which contradicts the assumption that Γ is balanced.
The kernelization result above is obtained by using the fact that when Γ is balanced, the constraints in CSP(Γ) can be replaced by linear polynomials.We show in the next theorem that this approach fails when Γ is not balanced.
Theorem 4.4 ( ).Let R be a k-ary relation that is not balanced.Then there exists u ∈ {0, 1} k \ R for which there exists no polynomial p u over any ring E that captures u with respect to R.

Characterization of symmetric CSPs with linear sparsification
In this section, we characterize the symmetric constraint languages Γ for which CSP(Γ) has a linear sparsification.
Definition 5.1.We say a k-ary Boolean relation R is symmetric, if there exists S ⊆ {0, 1, . . ., k} such that a tuple x = (x 1 , . . ., x k ) is in R if and only if weight(x) ∈ S. We call S the set of satisfying weights for R.
We will say that a constraint language Γ is symmetric, if it only contains symmetric relations.We will prove the following theorem at the end of this section.
If Γ is balanced, then CSP(Γ) has a kernel with O(n) constraints that can be stored in O(n log n) bits.If Γ is not balanced, then CSP(Γ) does not have a generalized kernel of size O(n 2−ε ) for any ε > 0, unless NP ⊆ coNP/poly.
To show this, we use the following lemma.).
We now give the main lemma that is needed to prove Theorem 5.2.It shows that if a relation is symmetric and not balanced, it must cone-define 2-or.
Lemma 5.4.Let R be a symmetric (Boolean) relation of arity k.If R is not balanced, then R cone-defines 2-or.
Proof.Let f be a balanced operation that does not preserve R. Since f has integer coefficients, it follows that there exist (not necessarily distinct) r 1 , . . ., r m ∈ R, such that Claim 5.5 ( ).Let s 1 , . . ., s m ∈ S and t ∈ U such that There exist distinct i, j, ∈ [m] with i, j odd and even, such that s i − s + s j ∈ {0, . . ., k}.
Use Claim 5.5 to find i, j, such that s i − s + s j ∈ {0, . . ., k}.We consider two options.If s i − s + s j ∈ U , then define d := s i − s + s j , a := s i , b := s , and c := s j and we are done.The other option is that Using the lemma above, we can now prove Theorem 5.2.
Proof of Theorem 5.2.If Γ is balanced, it follows from Theorem 4.1 that CSP(Γ) has a kernel with O(n) constraints that can be stored in O(n log n) bits.Note that the assumption that Γ is symmetric is not needed in this case.
If the symmetric constraint language Γ is not balanced, then Γ contains a symmetric relation R that is not balanced.It follows from Lemma 5.4 that R cone-defines the 2-or relation.Thereby, we obtain from Theorem 3.5 that CSP(Γ) has no generalized kernel of size O(n 2−ε ) for any ε > 0, unless NP ⊆ coNP/poly.

Low-arity classification
In this section, we will give a full classification of the sparsifiability for constraint languages that consist only of low-arity relations.The next results will show that in this case, if the constraint language is not balanced, it can cone-define the 2-or relation.

Theorem 6.2 ( ). A relation of arity 2 is balanced if and only if it is not cone-interdefinable with the 2-or relation.
Theorem 6.3 ( ).Suppose that U ⊆ {0, 1} 3 is an arity 3 Boolean relation that is not balanced.Then, the 2-or relation is cone-definable from U .
Combining the results in this section with the results in previous sections, allows us to give a full classification of the sparsifiability of constraint languages that only contain relations of arity at most three.Observe that any k-ary relation R such that R = ∅ and {0, 1} k \ R = ∅ cone-defines the 1-or relation.Since we assume that Γ is intractable in the next theorem, it follows that k is always defined and k ∈ {1, 2, 3}.Theorem 6.4.Let Γ be an intractable Boolean constraint language such that each relation therein has arity ≤ 3. Let k ∈ N be the largest value for which k-or can be cone-defined from a relation in Γ.Then CSP(Γ) has a kernel with O(n k ) constraints that can be encoded in O(n k log k) bits, but for any ε > 0 there is no kernel of size O(n k−ε ), unless NP ⊆ coNP/poly.Proof.To show that there is a kernel with O(n k ) constraints, we do a case distinction on k.
(k = 1) If k = 1, there is no relation in Γ that cone-defines the 2-or relation.It follows from Observation 6.1 and Theorems 6. (k = 3) Given an instance (C, V ), it is easy to obtain a kernel of with O(n 3 ) constraints by simply removing duplicate constraints.This kernel can be stored in O(n 3 ) bits, by storing for each relation R ∈ Γ and for each tuple ( Since |Γ| is constant and there are O(n 3 ) such tuples, this results in using O(n 3 ) bits.
It remains to prove the lower bound.By definition, there exists R ∈ Γ such that R cone-defines the k-or relation.Thereby, the result follows immediately from Theorem 3.5.Thus, CSP(Γ) has no kernel of size O(n k−ε ) for any ε > 0, unless NP ⊆ coNP/poly.

Conclusion
In this paper we analyzed the best-case and worst-case sparsifiability of CSP(Γ) for intractable finite Boolean constraint languages Γ.First of all, we characterized those Boolean CSPs for which a nontrivial sparsification is possible, based on the number of non-satisfying assignments.
Then we presented our key structural contribution: the notion of balanced constraint languages.We have shown that CSP(Γ) allows a sparsification with O(n) constraints whenever Γ is balanced.The constructive proof of this statement can be transformed into an effective algorithm to find a series of low-degree polynomials to capture the constraints, which earlier had to be done by hand.By combining the resulting upper and lower bound framework, we fully classified the symmetric constraint languages for which CSP(Γ) allows a linear sparsification.Furthermore, we fully classified the sparsifiability of CSP(Γ) when Γ contains relations of arity at most three, based on the arity of the largest or that can be cone-defined from Γ.It follows from results of Lagerkvist and Wahlström [17] that for constraint languages of arbitrary arity, the exponent of the best sparsification size does not always match the arity of the largest or cone-definable from Γ. (This will be described in more detail in the upcoming journal version of this work.)Hence the type of characterization we presented is inherently limited to low-arity constraint languages.It may be possible to extend our characterization to languages of arity at most four, however.
The ultimate goal of this line of research is to fully classify the sparsifiability of CSP(Γ), depending on Γ.In particular, we would like to classify those Γ for which O(n) sparsifiability is possible.In this paper, we have shown that Γ being balanced is a sufficient condition to obtain a linear sparsification; it is tempting to conjecture that this condition is also necessary.
We conclude with a brief discussion on the relation between our polynomial-based framework for linear compression and the framework of Lagerkvist and Wahlström [17].They used a different method for sparsification, based on embedding a Boolean constraint language Γ into a constraint language Γ defined over a larger domain D, such that Γ is preserved by a Maltsev operation.This latter condition ensures that CSP(Γ ) is polynomialtime solvable, which allows CSP(Γ) to be sparsified to O(n) constraints when D is finite.It turns out that the Maltsev-based linear sparsification is more general than the polynomialbased linear sparsification presented here: all finite Boolean constraint languages Γ that are balanced, admit a Maltsev embedding over a finite domain (the direct sum of the rings Z/q u Z over which the capturing polynomials are defined) and can therefore be linearly sparsified using the algorithm of Lagerkvist and Wahlström.Despite the fact that our polynomialbased framework is not more general than the Maltsev-based approach, it has two distinct advantages.First of all, there is a straight-forward decision procedure to determine whether a constraint can be captured by degree-1 polynomials, which follows from the proof of Theorem 4.1.To the best of our knowledge, no decision procedure is known to determine whether a Boolean constraint language admits a Maltsev embedding over a finite domain.The second advantage of our method is that when the polynomial framework for linear compression does not apply, this is witnessed by a relation in Γ that is violated by a balanced operation.As we have shown, in several scenarios this violation can be used to construct a sparsification lower bound to give provably optimal bounds.It would be interesting to determine whether the Maltsev-based framework for sparsification is strictly more general than the polynomial-based framework.We are not aware of any concrete Boolean constraint language Γ for which CSP(Γ) admits a Maltsev embedding over a finite domain, yet is not balanced.

A.1 Proofs omitted from Section 2
Proof of Proposition 2.4.It suffices to show that if a relation T is not balanced, then there exists an alternating operation that does not preserve T .Let f be a k-ary balanced operation that does not preserve T .Then there exist tuples t 1 , . . ., t k in T such that is not in T , where the sum of the α i is equal to 1 (and where we may assume that no α i is equal to 0).For each positive α i , replace α i t i in the sum with Each tuple then has coefficient +1 or −1 in the sum; since the sum of coefficients is +1, by permuting the sum's terms, the coefficients can be made to alternate between +1 and −1.
For the proof of Proposition 2.9, we will need the following additional theorem.
Theorem A.1.(Follows from [3].) Let Γ be a constraint language over a finite set D such that each unary operation u : D → D that preserves Γ is a bijection.Then, there exists a linear-parameter transformation from CSP(Γ * ) to CSP(Γ).
Note that in particular, an intractable Boolean constraint language can only be preserved by unary operations that are bijections.Hence for intractable Boolean Γ, there is a linearparameter transformation from CSP(Γ * ) to CSP(Γ).Definition A.2.A relation T ⊆ D k is pp-definable (short for primitive positive definable) from a constraint language Γ over D if there exists an instance (C, V ) of CSP(Γ) and there exist pairwise distinct variables x 1 , . . ., x k ∈ V such that, for each map f : {x 1 , . . ., x k } → {0, 1}, it holds that f can be extended to a satisfying assignment of the instance if and only if

Proof of Theorem
The following is a known fact; for an exposition, we refer the reader to Theorems 3.13 and 5.1 of [4].
For each variable v ∈ V , introduce a primed variable v .By Proposition A.3, the relation = (that is, the relation {(0, 1), (1, 0)}) is pp-definable from Γ * .Fix such a pp-definition, and let d be the number of variables in the definition.For each v ∈ V , include in C all constraints in the pp-definition of =, but where the variables are renamed so that v and v are the distinguished variables, and the other variables are fresh.
The number of variables used so far in C is nd.
For each b ∈ {0, 1}, introduce a variable z b , and include the constraint , we use the assumption that T is cone-definable from a relation in Γ to include a constraint in C that has the same effect as T (v 1 , . . ., v k ).In particular, assume that T is cone-definable from U ∈ Γ via the tuple (y 1 , . . ., y ), and that U has arity .Include in C the constraint U (w 1 , . . ., w ), where, for each i ∈ [ ], the entry w i is defined as follows: The set V of variables used in C is the union of V ∪ {v | v ∈ V } ∪ {z 0 , z 1 } with the other variables used in the copies of the pp-definition of =.We have |V | = nd + 2. It is straightforward to verify that an assignment f : V → {0, 1} satisfies C if and only if there exists an assignment f : V → {0, 1} of f that satisfies C .

A.2 Proofs omitted from Section 3
We start by proving the main Theorem of this section, using the other lemmas in the section.
Proof of Theorem 3.1.Suppose that for all R ∈ Γ, it holds that |R| = 2 k − 1.We give the following kernelization procedure.Suppose we are given an instance of CSP(Γ), with set of constraints C. We show how to define C ⊆ C. Suppose that there exists R ∈ Γ with |R| = 2 k − 1.It follows from Lemma 3.6 that R cone-defines k-or.Since Γ is intractable, it now follows from Theorem 3.5 that CSP(Γ) has no generalized kernel of size O(n k−ε ), unless NP ⊆ coNP/poly.
To prove Theorem 3.3, we use the following two theorems, that were proven by a subset of the current authors [15].We recall the required terminology.Let E be a ring.Define d-Polynomial root CSP over E as the problem whose input consists of a set L of polynomial equalities over E of degree at most d, over a set of variables V .Each equality is of the form p(x 1 , . . ., x k ) = 0 (over E).The question is whether there exists a Boolean assignment to the variables in V that satisfies all equalities in L.
Theorem A.4 ([15,Theorem 16]).There is a polynomial-time algorithm that, given an instance (L, V ) of d-Polynomial root CSP over Z/mZ for some fixed integer m ≥ 2 with r distinct prime divisors, outputs an equivalent instance (L , V ) of d-Polynomial root CSP over Z/mZ with at most r • (n d + 1) constraints such that L ⊆ L.
Note that if m is a prime power, m has only one distinct prime divisor and thereby r = 1 in the above theorem statement.
We say a field F is efficient if the field operations and Gaussian elimination can be done in polynomial time in the size of a reasonable input encoding.
Theorem A.5 ([15,Theorem 5]).There is a polynomial-time algorithm that, given an instance (L, V ) of d-Polynomial root CSP over an efficient field F , outputs an equivalent instance (L , V ) with at most n d + 1 constraints such that L ⊆ L.
Observe that the above theorem statement in particular applies to instances of d-Polynomial root CSP over Q, since Q is an efficient field.
Suppose we are given a graph G = (V, E) on n vertices and integer k ≤ n, forming an instance of the Vertex Cover problem.The question is whether there is a set S of k vertices, such that each edge has at least one endpoint in S. We create an equivalent instance (C, V ) of CSP(Γ * ) as follows.We introduce a new variable x v for each v ∈ V .For each edge {u, v} ∈ E, we add the constraint 2-or(x u , x v ) to C.
At this point, any vertex cover in G corresponds to a satisfying assignment, and vice versa.It remains to ensure that the size of the vertex cover is bounded by k.Let H n,k be the n-ary relation given by H n,k = {(x 1 , . . ., x n ) | x i ∈ {0, 1} for all i ∈ [n] and i∈ [n] x i = k}.By Proposition A.3, we obtain that Γ * pp-defines all Boolean relations.It follows from [17,Lemma 17] that Γ * pp-defines H n,k using O(n + k) constraints and O(n + k) existentially quantified variables.We add the constraints from this pp-definition to C, and add the existentially quantification variables to V .This concludes the construction of C. It is easy to see that C has a satisfying assignment if and only if G has a vertex cover of size k.Furthermore, we used O(n + k) ∈ O(n) variables and thereby this is a linear-parameter transformation from Vertex Cover to CSP(Γ * ∪ ∆).
(k ≥ 3) In this case there is a trivial linear-parameter transformation from CSP(∆) to CSP(Γ * ∪ ∆).It is easy to verify that CSP(∆) is equivalent to k-CNF-SAT.The result now follows from the fact that for k ≥ 3, k-CNF-SAT has no kernel of size O(n k−ε ) for any ε > 0, unless NP ⊆ coNP/poly [7].
As the last result of the section, we prove that k-ary Boolean relations with exactly one falsifying assignment cone-define k-or.

A.3 Proofs omitted from Section 4
To give the proofs that were omitted from Section 4, we need the following additional definitions.
Definition A.9.We say an m × n matrix A is a diagonal matrix, if all entries a i,j with i = j are zero.Thus, all non-zero elements occur on the diagonal.
Note that by the above definition of diagonal matrices, a matrix can be diagonal even if it is not a square matrix.
We denote the greatest common divisor of two integers x and y as gcd(x, y).Recall that by Bézout's lemma, if gcd(x, y) = z then there exist integers a and b such that ax + by = z.We will use x | y to indicate that x divides y (over the integers) and x y to indicate that it does not.The proof of the following lemma was contributed by Emil Jeřábek.
Proof of Lemma 4.2.We prove the contrapositive.Suppose u / ∈ span Z ({s 1 , . . ., s m }), thus u cannot be written as a linear combination of the rows of S over Z; equivalently, the system Define M to be the following m × m matrix M := M 0 0 1 , then M has an inverse over Z/qZ that is given by the following matrix Define S := M AN and verify that meaning that the first m − 1 rows of S are equal to the first m − 1 rows of S , and the last row of S is given by the row vector a m N .
The following two claims will be used to show that proving the lemma statement for matrix S, will give the desired result for A.
Claim A.12.Let b := (0, . . ., 0, c) for some constant c.The system Sx ≡ q b has a solution, if and only if the system Ax ≡ q b has a solution.
Proof.Let x be a solution for Ax ≡ q b.Define Observe that by the definitions of M and b, M b ≡ q b, which concludes this direction of the proof.
For the other direction, let x be a solution for M AN x ≡ q b.Define x := N x .Then M −1 M AN x ≡ q M −1 b and thus AN x ≡ q M −1 b and thereby Ax ≡ q M −1 b.By the definition of M −1 and b, we again have M −1 b ≡ q b.Claim A.13. s m ∈ span q ({s 1 , . . ., s m−1 }) if and only if a m ∈ span q ({a 1 , . . ., a m−1 }).
It follows from Claims A.12 and A.13, that it suffices to show that if Sx = (0, . . ., 0, c) T has no solutions for any c ≡ q 0, then s m ∈ span q ({s 1 , . . ., s m−1 }).So suppose s m / ∈ span q ({s 1 , . . ., s m−1 }), we show that the system has a solution for some non-zero c.Observe that since S (the first m − 1 rows of S) is a diagonal matrix, there must exist i ∈ [m − 1] for which there is no α i satisfying s i,i • α i ≡ q s m,i .Otherwise, it is easy to see that i∈[m−1] α i s i ≡ q s m , contradicting that s m / ∈ span q ({s 1 , . . ., s m−1 }).We now do a case distinction.
Suppose there exists i ∈ [m − 1] such that s i,i ≡ q 0, while s m,i ≡ q 0. Let x = (0, . . ., 0, 1, 0, . . ., 0) be the vector with 1 in the i'th position and zeros in all other positions.It is easy to verify that Sx ≡ q (0, . . ., 0, s m,i ) T and thereby the system Sx ≡ q b has a solution for c = s m,i .
Otherwise, choose i such that there exists no integer α i satisfying s i,i • α i ≡ q s m,i and s i,i ≡ q 0. It is given that q is a prime power, let q = p k for prime p.Let 0 ≤ < k be the largest integer such that p | s i,i over the integers.We consider the following two cases.Suppose p | s m,i .Let c such that s i,i ≡ q c • p and choose d such that s m,i ≡ q d • p .Note that gcd(c, q) = 1.It follows from Bézout's lemma that c has an inverse c −1 such that cc −1 ≡ q 1.Then s i,m ≡ q (d • c −1 )s i,i , which is a contradiction with the assumption that no integer α i exists such that s i,i • α i ≡ q s i,m .Suppose p s m,i .Define x := (0, . . ., 0, p k− , 0, . . ., 0) T as the vector with p k− in position i.Then Sx ≡ q (0, . . ., 0, p k− • s i,i , 0, . . ., 0, p k− • s m,i ) T .Since p | s i,i it follows that p k− • s i,i ≡ q 0. Furthermore, since p s m,i , it follows that p k− •s m,i ≡ q 0, and thereby the system Sx ≡ q b has a solution for b := (0, . . ., 0, p k− s m,i ).
The contrapositive of Lemma 4.3 states that if a m / ∈ span q ({a 1 , . . ., a m−1 }), then there exists c ≡ q 0 for which Ax ≡ q b has a solution.A method to construct such a solution x follows from our proof above.In the context of capturing a Boolean relation R by degree-1 polynomials, this constructive proof effectively shows the following: given a prime power q over which a certain tuple u / ∈ R can be captured, one can constructively find the coefficients x of a polynomial that captures u by following the steps in the proof.
Proof of Theorem 4.4.Suppose R is not balanced.By Proposition 2.4, this implies R is violated by an alternating operation.Let f be an alternating operation that does not preserve R, such that f (y 1 , . . ., y m ) := m i=1 (−1) i+1 y i for some odd m, and for some (not necessarily distinct) r 1 , . . ., r m ∈ R we have f (r 1 , . . ., r m ) = u with u / ∈ R.
Suppose for contradiction that there exists a linear polynomial p u over a ring E u , such that p u captures u over E u .Let r i := (r i,1 , . . ., r i,k ) for i ∈ [m].Since f (r 1 , . . ., r m ) = u, we have the following equality over Z: (4) Since r j,i ∈ {0, 1} for all i ∈ [k] and j ∈ [m], equation (4) holds over any ring, so in particular over E u .
all tuples in its domain.A relation over the set D is a subset of D k ; here, k is a natural number called the arity of the relation.Throughout, we assume that each relation is over a finite set D. A Boolean relation is a relation over {0, 1}.Definition 2.3.For each k ≥ 1, we use k-or to denote the relation {0, 1} k \ {(0, . . ., 0)}.
a shorter alternating sum with result t.We obtain a, b, c, and d by the induction hypothesis.Thereby, we have obtained a, b, c ∈ S, d ∈ U such that a − b + c = d.It now follows from Lemma 5.3 that R cone-defines 2-or.
2 and 6.3 that thereby, Γ is balanced.It now follows from Theorem 4.1 that CSP(Γ) has a kernel with O(n) constraints that can be stored inO(n log n) bits.(k = 2) If k = 2, there is no relation R ∈ Γ with |R| = 2 3 − 1 = 7,as otherwise by Lemma 3.6 such a relation R would cone-define 3-or which is a contradiction.Thereby, it follows from Theorem 3.1 that CSP(Γ) has a sparsification with O(n 3−1 ) = O(n 2 ) constraints that can be encoded in O(n 2 log n) bits.
A.1.The desired transformation is the final polynomial-time reduction given in the proof of Theorem 4.7 of [3].This reduction translates an instance of CSP(Γ * ) with n variables to an instance of CSP(Γ ∪ {= D }) with n + |D| variables; here, = D denotes the equality relation on domain D. Each constraint of the form = D (v, v ) may be removed (while preserving satisfiability) by taking one of the variables v, v , and replacing each instance of that variable with the other.The resulting instance of CSP(Γ) has ≤ n + |D| variables.
For each constraint R(x 1 , . . ., x ) ∈ C where R is a relation of arity < k, add one such constraint to C (thus removing duplicate constraints).Note that this adds at most O(n ) constraints for each -ary relation R ∈ Γ.For a k-ary relation R ∈ Γ, let C R contain all constraints of the form R(x 1 , . . ., x k ).For all k-ary relations R with |R| < 2 k − 1, apply Lemma 3.4 to obtain C R ⊆ C R such that |C R | = O(n k−1 ) and any Boolean assignment satisfying C R also satisfies C R .Add C R to C .This concludes the definition of C .Note that the procedure removes constraints of the form R(x 1 , . . ., x k ) with |R| = 2 k , as these are always satisfied.It is easy to verify that |C | ≤ |Γ| • O(n k−1 ) = O(n k−1 ).Since each constraint can be stored in O(log n) bits, this gives a kernel of bitsize O(n k−1 log n).