On the Constant-Factor Approximability of Minimum Cost Constraint Satisfaction Problems
Abstract
We study minimum cost constraint satisfaction problems (MinCostCSP) through the algebraic lens. We show that for any constraint language which has the dual discriminator operation as a polymorphism, there exists a -approximation algorithm for where is the domain. Complementing our algorithmic result, we show that any constraint language where admits a constant-factor approximation must have a near-unanimity (NU) polymorphism unless P = NP, extending a similar result by Dalmau et al. on MinCSPs. These results imply a dichotomy of constant-factor approximability for constraint languages that contain all permutation relations (a natural generalization for Boolean CSPs that allow variable negation): either has an NU polymorphism and is -approximable, or it does not have any NU polymorphism and is NP-hard to approximate within any constant factor. Finally, we present a constraint language which has a majority polymorphism, but is nonetheless NP-hard to approximate within any constant factor assuming the Unique Games Conjecture, showing that the condition of having an NU polymorphism is in general not sufficient unless UGC fails.
Keywords and phrases:
Constraint satisfaction problems, approximation algorithms, polymorphismsCategory:
APPROXFunding:
Euiwoong Lee: Supported in part by NSF grant CCF-2236669.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysisAcknowledgements:
The authors would like to thank anonymous reviewers for their helpful comments.Editors:
Alina Ene and Eshan ChattopadhyaySeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Constraint satisfaction problems (CSPs) are a central topic of study in theoretical computer science. In an instance of a CSP, we are given a finite set of variables taking values in a finite domain and a finite set of constraints on these variables, and our goal is to find an assignment to the variables so that all constraints are satisfied. CSPs provide a very expressive framework that encompasses many natural combinatorial problems, including satisfiability problems, graph coloring, and solving linear systems. CSPs in their full generality are NP-hard, and therefore it is natural to consider restrictions which lead to interesting tractable subclasses of CSPs. One very influential type of restrictions is to restrict the constraint language, that is, to restrict the set of relations that can be used as constraints. In this line of work, the ultimate goal is to obtain a dichotomy, if it exists, which characterizes the boundary between tractable and NP-hard constraint languages. The first such result, obtained by Schaffer [41], gave a complete classification of tractable Boolean CSPs. In their landmark paper [22], Feder and Vardi conjectured that a dichotomy exists for CSPs over general domains. This conjecture, known as the CSP Dichotomy Conjecture, led to a series of fruitful work culminating in the proof of the conjecture obtained independently by Bulatov [12] and by Zhuk [46].
Compared to the standard decision variant of CSPs, there are many natural optimization CSP variants whose complexity landscape is less understood. The most well-studied optimization variant is arguably the maximum constraint satisfaction problem (MaxCSP), where the objective is to find an assignment that maximizes the number of satisfied constraints. Interesting examples in this class include maximum cut and maximum satisfiability problems. For MaxCSPs, Raghavendra showed that the optimal approximation ratio111For a maximization (resp. minimization) problem, an approximation algorithm achieves an approximation ratio of , if on an input instance with global optimal , it produces a solution whose objective value is at least (resp. at most ). can be obtained by solving and rounding a generic semidefinite programming relaxation of the problem [40] (note that a constant approximation ratio for MaxCSP can be trivially obtained by uniform random assignment), assuming that the Unique Games Conjecture (UGC) [31] holds. However, the exact approximation ratio is not explicit in Raghavendra’s result, and the ratios for many interesting MaxCSPs are still open (see e.g., [8, 9]). For MinCSPs, the objective is to minimize the number of unsatisfied constraints. MinCSP can be much harder than the corresponding MaxCSP in terms of the approximation ratio. In particular, it is at least as hard as the decision problem since an approximation algorithm has to satisfy every constraint when the instance is satisfiable. Valued CSPs generalize MinCSP by replacing 0-1 constraints with valued constraints, so that for any constraint different partial assignments can incur different costs. Thapper and Živný obtained a complexity dichotomy for the task of exact minimization for finite-valued CSPs [45], but the approximability question for this problem is still poorly understood. Ene et al. showed that under some mild technical assumption, there is a generic linear programming relaxation for finite-valued CSPs that is optimal for constant-factor approximation, unless UGC fails [21]. But unlike for MaxCSPs, it is unknown how to round this linear program. Dalmau et al. gave some algebraic conditions which indicate where the boundary of constant-factor approximability (or the lack thereof) for valued CSPs may lie [18], but a full characterization of constant-factor approximability is still unresolved.
In this work, we consider an optimization CSP variant called minimum cost CSP (MinCostCSP). In this variant, assigning any value to a variable comes with a cost, and the cost is a function of the variable-value pair. Our goal is to find a satisfying assignment that minimizes the total cost. MinCostCSP can be seen as a mixed variant between decision and optimization problems, in that we are still required to find a satisfying assignment. It can also be thought of as a special case of valued CSP, where we have some unary constraints representing the variable costs and all other constraints incur 0 cost if satisfied or infinite cost otherwise. MinCostCSP is a very natural CSP variant which avoids the full generality of valued CSPs, yet still includes many interesting problems, such as graph and hypergraph vertex cover, min-ones CSP [30] and minimum solution CSP [29].
We study the approximability, and in particular constant-factor approximability of MinCostCSP. Like many aforementioned results, our study is based on the universal-algebraic approach (see e.g., [34] for a survey on this approach applied to the exact optimization of valued CSPs), where we investigate the algebraic structure of any constraint language via its polymorphisms, which can be thought of certain high-dimensional symmetry that exists in the space of satisfying assignments. More specifically, we seek to algorithmically exploit the existence of desirable polymorphisms or show hardness results based on the lack thereof.
Our contribution
We obtain constant-factor approximability for constraint languages that have the dual discriminator operation as a polymorphism. These constraint languages can be thought of as generalization of 2-SAT to arbitrary finite domains. We give two algorithms for this class of problems, one using a greedy approach and the other based on a natural linear programming relaxation of the problem. Both algorithms crucially use the consistency notion called (2,3)-minimality [4].
Theorem 1.
Let be a constraint language over some domain that has the dual discriminator operation as its polymorphism. Then can be -approximated in polynomial time.
Complementing our algorithmic result, we obtain the following hardness condition which says that constant-factor approximation is NP-hard for any constraint language which does not have a near-unanimity (NU) polymorphism.
Theorem 2.
Let be a constraint language such that has a constant-factor approximation, then has a NU polymorphism, unless P = NP.
Near unanimity operations are well-studied in universal algebra (see e.g., [1]), and they have also appeared in the study of CSPs [22, 18, 16]. In particular, Dalmau et al. showed that for valued CSPs the existence of NU polymorphisms is also a necessary condition for constant-factor approximability [18]. It can be verified that for MinCostCSP over the Boolean domain, the condition of having an NU polymorphism is not only necessary but also sufficient for constant-factor approximability (see Remark 40 for more discussion). However, as soon as the domain has at least 3 elements, there exist constraint languages which have NU polymorphisms yet does not admit constant-factor approximation, unless the UGC fails. We present such an example in Section 4.3.
Finally, as an application of our hardness and algorithmic results, we fully classify the constant-factor approximability of constraint languages that include all permutation relations, showing that the existence of an NU polymorphism is also a sufficient condition for this class. These languages can be thought of as a natural generalization of Boolean CSPs where we are allowed to apply constraints to negated variables. Our classification relies on the classification of homogeneous algebras by Marchenkov [36].
Theorem 3.
Let be a constraint language over some domain that contains all permutation relations over . Then can be -approximated if has an NU polymorphism, and is NP-hard to approximate within any constant factor otherwise.
Related work
The approximability of MaxCSP, MinCSP, as well as MinCostCSP over the Boolean domain was fully classified by Khanna et al. [30]. In particular, for MinCostCSP they obtained the following complete classification: can be solved to optimality in polynomial time if is “width-2 affine”, that is, can be expressed as a conjunction of linear equations over where each equation has at most 2 variables; the problem can be approximated within a constant factor in polynomial time if can be expressed as a 2CNF-formula, or if is IHB-B (expressible as a CNF formula where each clause is of the form , , or where for some depending on ), or if is IHB-B (defined analogously to IHB-B with every literal replaced by its negation). Otherwise, is NP-hard to approximate within any constant factor. (See Remark 40 for a more detailed discussion in the context of our results.)
Over the general domain, a dichotomy for solving optimally was obtained by Takhanov [44]. Takhanov’s characterization is based on local algebraic conditions satisfied by polymorphisms of .
Kumar et al. showed that for a large class of covering and packing problems that can be expressed as MinCostCSP (they called it “Strict-CSP”) over the general domain, a generic linear programming relaxation gives the optimal approximation ratio achievable in polynomial time, assuming the Unique Games Conjecture [35]. Their result generalizes the earlier UGC-based hardness results for vertex cover [33] and the -uniform hypergraph vertex cover problems [2].
An important special case for where consists of one single binary relation has been studied in the literature under the name “min-cost graph homomorphism” (in the case where the binary relation is symmetric) or “min-cost di-graph homomorphism” (in the general binary case). Dichotomy results for optimally solving these problems are known based on graph-theoretic properties [25, 27]. Hell et al. gave a similar dichotomy for constant-factor approximability for the min-cost graph homomorphism problem in the case where the graph (equivalently, the binary relation) is reflexive (every vertex has a self-loop) or irreflexive (no vertex has a self-loop) [26].222We note that an ICALP’19 paper [39] claimed that the following dichotomy for constant-factor approximability holds over all (undirected) graphs: either a graph has a conservative majority polymorphism and is constant-factor approximable, or it does not and is NP-hard to approximate within any constant factor. Our Theorem 45 contradicts this claim under the Unique Games Conjecture and .
Another CSP variant closely related to MinCostCSP is ListCSP which can be thought of as a special case of MinCostCSP where the costs take values in . Bulatov obtained a complete classification for this problem (under the name “conservative CSP”) based on the algebraic approach [10] (see also [3, 11]).
Organization of the paper
The rest of the paper is organized as follows. In Section 2, we formally define the problems and introduce some algebraic concepts that are needed throughout the paper. In Section 3, we present our main algorithmic results, proving Theorem 1. In Section 4, we prove some algebraic conditions sufficient for reductions between MinCostCSPs, and use them to prove Theorem 2. Finally, in Section 5, we use our results to give a dichotomy of constant-factor approximability for MinCostCSPs that contain all permutation relations, proving Theorem 3.
2 Preliminaries
2.1 CSP, ListCSP, and MinCostCSP
Let be a finite set. A relation over is a subset for some positive integer , where is called the domain of and is called the arity of . A set of relations over the same domain is called a constraint language. Throughout this paper, any constraint language we consider will be assumed to contain finitely many relations whose common domain will be denoted by . The elements in will be referred to as labels.
Definition 4.
Let be a constraint language. An instance of is a tuple , where is a finite set of variables and a finite set of constraints. Each constraint is of the form , where is a relation in with some arity and a -tuple of variables. An assignment for is a function . We say that satisfies a constraint if , and we say that is a satisfying assignment for if satisfies every constraint in .
One closely related variant of CSP is the following ListCSP problem. This problem has also been referred to as conservative CSP in the literature.
Definition 5.
Let be a constraint language. An instance of is a tuple , where is a finite set of variables and a finite set of constraints, as in the definition of . In addition to and , we are also given a subset for every variable . We say that is a satisfying assignment for if satisfies every constraint in and for every .
ListCSP may be equivalently viewed as the ordinary CSP where all unary constraints are allowed in addition. In this paper, we will mainly focus on MinCostCSP, which further generalizes ListCSP.
Definition 6.
Let be a constraint language. An instance of is a tuple , where and are the same as they are in the definition of , and we are also given a function . For any assignment for , the cost of is defined to be . The goal is find a satisfying assignment with the minimum cost.
For any MinCostCSP instance , the cost of any optimal solution is denoted by , where ranges over all satisfying assignments for . Although we allowed infinite costs in the definition of MinCostCSP, this is not essential in the context of approximability. In fact, we may simulate infinite cost by setting costs to be prohibitively high, say larger than times the maximum of any other finite cost, so that no approximation algorithm will pick the label. The inclusion of the infinite cost conveniently allows us to assume without loss of generality that contains all unary relations.
Observation 7.
Let be a constraint language over some domain and . Then and are equivalent. Namely, any instance of can be solved as an instance of and vice versa.
Proof.
One direction is clear since . For the other direction, for any unary constraint where (the constraint which says the label of must be in ), we simply set for any .
Observation 7 implies that contains as a special case. In particular, if is NP-hard, then for finding any satisfying assignment regardless of cost is NP-hard as well.
2.2 Polymorphisms
Definition 8.
Let be a -ary operation on the domain , and some -ary relation over the same domain. We say that preserves (or is a polymorphism of ) if for every we have , where for every . Given a constraint language we say that preserves (or is a polymorphism of ) if preserves every . We use to denote the set of all polymorphisms of , and (abusing notation slightly) to denote the set of all polymorphisms of .
It follows directly from the definition that for any , , the projection operation is a polymorphism. Also, any composition of polymorphisms is still a polymorphism. A set of operations satisfying these two properties is known as a clone.
Definition 9.
A clone over is a set of operations for which the following holds:
-
contains the projection operation for every , .
-
For every -ary and -ary , the -ary function defined by
is also in .
Clones have been studied extensively in the universal algebra community, and many complexity-theoretic classification results for CSPs depend on classification results for their corresponding family of polymorphism clones (see e.g. [6] for more on polymorphism clones).
We say that a function is conservative, if for every . It is immediate from the definition that if is constraint language that contains all unary relations, then every is conservative.
Definition 10.
Let be a -ary operation for some . We say that is a near-unanimity (NU) operation if for every ,
In other words, if all but one inputs are equal to some , then outputs . If , then is also called a majority operation.
Example 11.
Let the dual discriminator operation be defined by
Then is a majority operation. This operation will be featured heavily in our algorithmic results.
Constraint languages that are preserved by some NU operation enjoy the following nice property.
Definition 12.
Let be a -ary relation. Let be the set of -tuples whose entries are in and in increasing order. For any and , let and . We say that is -decomposable if for every , we have
We say that is -decomposable if every is -decomposable.
Theorem 13 (Theorem 3.5 in [28]).
Let be a constraint language and . If is preserved by some -ary NU operation, then is -decomposable.
3 Algorithms for the dual discriminator
In this section, we give two -approximation algorithms for where is a constraint language over preserved by the dual discriminator operation, thus proving Theorem 1. Both algorithms will assume that the input instance is a satisfiable binary, (2,3)-minimal instance. We introduce and justify this assumption in Section 3.1, and then present a greedy algorithm in Section 3.2 and a LP-based algorithm in Section 3.3.
3.1 Reducing to satisfiable binary (2,3)-minimal instances
A CSP instance is binary, if every constraint in has arity at most 2. Theorem 13 allows us to assume that the input instance is binary, since it is preserved by the dual discriminator operation which is a 3-ary NU operation. For any binary instance , we may also write it as a triple , where we have one unary relation for every and one binary relation for every pair . Note that to write in this form we may take the intersection of relations with the same scope or add complete relation on some variable(s) if none exists.
Definition 14 (See e.g., [6]).
A binary CSP instance over domain is -minimal if
-
(a)
For every distinct , .
-
(b)
For every distinct , .
-
(c)
For every pairwise distinct and , there exists such that and .
Informally, the definition says that is (2,3)-minimal if any partial satisfying assignment (that is, a partial assignment that does not immediately falsify any constraint) to two variables can be extended to a partial satisfying assignment to three variables. Given a binary CSP instance , we may transform it into a -minimal instance using the following procedure:
Clearly, when the above procedure stops, the instance must be -minimal (otherwise the loop would have continued). The new instance may have constraints that are not in our original constraint language. However, since the new constraints are all obtained by pp-definitions from the original constraint language, they are preserved by the same polymorphisms (see Definition 27 and Theorem 28). In particular, the new instance is still preserved by the dual discriminator operation.
We say that a -minimal instance is trivial if at least one of the unary relations is empty, and it is nontrivial otherwise. A trivial -minimal instance has no satisfying assignment since no assignment can satisfy an empty relation. On the other hand, if the instance is nontrivial and its constraint language has bounded width, then such an instance is always guaranteed to have a satisfying assignment which we can find in polynomial time.
Theorem 15 ([4, 5]).
Let be a nontrivial -minimal instance whose constraint language has bounded width. Then has a satisfying assignment which can be found in polynomial time.
We will not define the term “bounded width” formally here (see Theorem 31 for a characterization). For us it is sufficient to note that any constraint language that is preserved by an NU polymorphism has bounded width [22], so any unsatisfiable instance will necessarily give rise to a trivial (2,3)-minimal instance. From now on we will assume that the (2,3)-minimal instance is nontrivial, and therefore satisfiable. Also, observe any satisfying assignment for the original instance will remain satisfying for the new (2,3)-minimal instance. This means any assignment we obtain on the new instance will give an approximation ratio at least as good on the original instance, and therefore we may shift our attention to this new instance instead.
We crucially use the following characterization for binary relations preserved by the dual discriminator operation. The same characterization was used by [16] in the context of robust satisfiability (these relations have also been studied under the name of 0/1/all relations [14]). We sketch a short proof here for completeness.
Lemma 16 (See e.g. [6, 16]).
Let be a binary relation. Then is preserved by the dual discriminator operation if and only if is of one of the following forms:
-
for some .
-
for some and .
-
for some and bijective .
Proof.
It is easy to verify that if is one of these three types then it is preserved by . Let us prove the other direction. Let and . For any , if there exist two distinct such that , then for any , we have also . In other words, we have . This is because we can find some by the definition of , and apply to the three pairs to obtain (observe that and ).
Now if we have two distinct such that and , then for every there are two distinct such that . By applying the above argument with and reversed we get that for every , , so it must be the case that .
Now assume that there exists exactly one such that and . Then there exists such that , so we have . Note that in this case we must have , for the existence of any other pair would imply that .
Finally, if and there is no such that , then there can also be no such that . So for every there is a unique such that , and we can find some bijective such that .
3.2 A greedy algorithm
We now present a greedy algorithm which is a generalization of a 2-approximation algorithm for MinOnes 2-SAT due to Gusfield and Pitt [24]. In this algorithm, we will greedily pick labels for the variables one by one, and each label we pick may potentially restrict the set of feasible labels for some other variables. For general CSPs, this restriction can be rather arbitrary and difficult to control. However, for binary -minimal instances preserved by the dual discriminator operation, the restriction is very simple: either the set of feasible labels is unchanged, or it is restricted to a singleton set (as is guaranteed by Lemma 16). This means for variables where proper restriction happens we can simply fix it to the label in the singleton set. On the other hand, the variables whose set of feasible labels didn’t change induce a sub-instance of the original instance and the algorithm may recurse on this sub-instance. This property guarantees that we will always produce a satisfying assignment, as is formalized in the following lemma.
Definition 17.
Let be a (2,3)-minimal instance. For any , and , we say that is fixed to by assigning to if and , or and . In other words, is the only feasible label left for if we assign the label to .
Lemma 18.
Let be a nontrivial (2,3)-minimal instance preserved by the dual discriminator operation. Let , , be the set of variables fixed by assigning to . For every , let be the unique label that is fixed to by assigning to . Let be any satisfying assignment for the induced (2,3)-minimal instance , then
is a satisfying assignment for .
Proof.
Clearly all unary constraints in are satisfied. Any binary constraint where is satisfied since is a satisfying assignment. The remaining two cases, where or , follow from the following claim:
Claim 19.
For every distinct and , if , then we have .
Proof.
This claim clearly holds for . Suppose . Since , by (2,3)-minimality we can find such that . This must coincide with , since is fixed by assigning to . Thus, we have . For , since , we may apply the claim and obtain that , so this constraint is satisfied. For , again since since , we may apply the claim and obtain that , so this constraint is also satisfied. It follows that all binary constraints in are satisfied by , so it is indeed a satisfying assignment for .
To guarantee a constant-factor approximation, we need to pick labels in a clever way. One naive idea is to compute the total cost incurred by variables fixed by each label and pick the label that minimizes this cost. However, this does not work because the optimum assignment may incur more cost but save by fixing more variables. One way to fix this naive idea is to consider a derived cost , instead of the original cost . In particular, when we face a decision for some variable (i.e., ), we pick the label that minimizes the total derived cost of fixed variables. We then pay times this cost towards reducing the derived cost of all variable-label pairs that are or could’ve been fixed by assignment to . The key idea here is that one of the labels in will be taken by the optimal assignment, so the amount we pay are always within a factor of from the total cost of the optimal assignment.
We now formally present the algorithm and its analysis. The pseudocode for the algorithm can be found in Algorithm 1.
Input: a (2,3)-minimal instance,
Output: a satisfying assignment for .
Initialization:
We start by making the following observations.
Observation 20.
Let be the values of when is returned. For every , .
Proof.
For variables fixed outside the while loop, this follows from Line 5. For variables that obtained its assignment inside the while loop, this follows from Lines 18 and 25 (since for every ).
Observation 21.
The value of never increases during the algorithm. In particular, for every and , we have .
Proof.
This is because is always nonnegative.
Observation 22.
For every and , we have at any point of the algorithm.
Proof.
This is because when an update happens at Line 22, the updated value for is equal to .
The guarantee on the approximation ratio is based on the following claim.
Claim 23.
Let be any satisfying assignment for . For each iteration of the while loop beginning at Line 6, let be the values of at the beginning and the end of the iteration respectively. Then we have
Proof.
Let the variables be defined as they are in the algorithm. For every and define the auxiliary variables
Note that the quantity is nonzero only if there exists some such that and , and this quantity is given by the value stored in at the beginning for Line 23. By construction (see Line 22), for any such we have
since is equal to the largest summand in the sum defining . It follows that
Here, the last equality follows from (see Line 18). On the other hand, for we must have for every , and therefore we have
This establishes the claim.
Theorem 24.
Algorithm 1 returns a satisfying assignment whose cost is at most times the optimal cost.
Proof.
The algorithm returns a satisfying assignment by Lemma 18.
3.3 An LP-based algorithm
We now present another approximation algorithm that is based on the basic linear programming (BLP) relaxation for the MinCostCSP problem [42, 35]. Given an instance , its BLP relaxation can be formulated as follows.
Recall that each constraint is represented by a pair where is some -ary relation and is a -tuple of variables to which is applied. Here in the LP formulation we abuse the notation slightly and think of each satisfying tuple also as a partial assignment , and is the label that assigns to . Informally, the linear program maintains a distribution of satisfying partial assignments for each constraint, and it requires that if a variable appears in multiple constraints, then the marginal distribution on this variable should be consistent across these constraints. The objective function to minimize is then the expected cost under these marginal distributions. It is easy to see that any integral assignment to corresponds to distributions supported on a single element, so this is indeed a relaxation of the original problem. We remark that in polynomial time we can actually enforce the marginal consistency requirement on any constant-sized set of variables, and thus obtain tighter relaxations on the so-called Sherali-Adams hierarchy ([42]). However, this will not be needed for our purpose.
For any MinCostCSP instance , let be the optimal value of the BLP relaxation for . Our LP-based algorithm is as follows. Note that as before, we assume that is given as a non-trivial -minimal instance.
Input: a (2,3)-minimal instance
Output: a satisfying assignment for .
In words, we remove labels that receive tiny LP probabilities (less than ) and solve the new instance. Observe that is nonempty for every , since at least one of the labels will get a probability that is at least .
Theorem 25.
Let be a nontrivial (2,3)-minimal instance. Then on input , Algorithm 2 returns in polynomial time a satisfying assignment to whose cost is at most .
Proof.
We first show that is indeed a (2,3)-minimal instance. We verify the conditions in Definition 14 one by one. For readers’ convenience, we restate the conditions in italic.
-
(a)
For every distinct , . This is equivalent to the statement . By symmetry, it is sufficient to show that . Let , then and . Since is (2,3)-minimal, we have that , so .
-
(b)
For every distinct , . By construction we have . To show the other inclusion, let us pick . By Lemma 16, we have the following two cases:
-
. In this case, we have . Since is nonempty, we have that .
-
. In this case, there is a unique such that . By the LP constraint, we have , and therefore and .
-
-
(c)
For every pairwise distinct and , there exists such that and . Similar to part (b), we again have two cases:
-
or . Since is (2,3)-minimal, there exists such that and . By Lemma 16, is either the unique element in such that , or the unique element in such that . In either case, we can conclude that , so as required.
-
and . In this case, since is non-empty, there exists some so we have and .
-
This establishes that is (2,3)-minimal. Note that every binary relation in is also of the three types described in Lemma 16, so it is also preserved by the dual discriminator operation. By Theorem 15, we can find a satisfying assignment for in polynomial time. Note that for this assignment, we have
4 NU polymorphism as necessary condition for constant-factor approximability
In this section, we establish the following necessary condition for the constant-factor approximability of problem. We note that Dalmau et al. [18] obtained a similar necessary condtion for the problem of MinCSP. We will closely follow their proof.
Theorem 26 (Theorem 2 restated).
Let be a constraint language. If has a constant-factor approximation, then contains a conservative NU polymorphism, unless P = NP.
4.1 Gadget reductions and primitive positive interpretations
Let us first establish some sufficient condition for reductions between MinCostCSPs. Given two constraint languages and , we write if the constant-factor approximability for implies the constant-factor approximability for . By definition, is transitive.
Definition 27 (pp-definition).
Let be a constraint language over and a -ary relation over the same domain. We say that pp-defines , if there exist some and a conjunction over variables consisting of relations in and the equality relation () over , such that
If is another constraint language over the same domain , then we say that pp-defines if pp-defines every relation in .
The following theorem establishes a connection (often referred to as Galois correspondence in the literature) between polymorphisms and pp-definitions. We say that a relation with arity is irreducible, if for every distinct , there exists such that .
Theorem 28 ([7, 23]).
Let be a constraint language and some -ary relation over the same domain. Then we have
-
if and only pp-defines .
-
If is irreducible, then if and only pp-defines without using the equality relation.
Definition 29 (pp-interpretation).
Let and be constraint languages over domains and respectively. We say that pp-interprets if there exist , , and a surjective function such that pp-defines the following relations:
-
as an -ary relation over .
-
For every with some arity , the relation
Here each is a -tuple over and we are thinking of as a flattened -tuple over .
-
The relation
Here again and are -tuples over and is a flattened -tuple.
We say that pp-interpretes in the first power if in the above definition. It is known in the case of standard decision CSP that the existence of a pp-interpretation implies a gadget reduction, where we simply replace constraints in with constraints in using the pp-definitions. However, in the case of MinCostCSP, for the purpose of the reduction we would also need to translate the costs between the two instances. This is straightforward for , but there seems to be no natural way of doing this if we are using a pp-interpretation with .
Lemma 30.
Let be a constraint language over and a constraint language over . If pp-interpretes in the first power and one of the following holds:
-
The equality relation over is in .
-
Every is irreducible.
Then
Proof.
Let and be as in the definition of pp-interpretation. Let be a instance. We define a instance as follows:
-
has the same set of variables as .
-
For each constraint , we would like to add a constraint to . To do this, without loss of generality assuming , we take the pp-definition of , which is of the form
Here are auxiliary variables with zero costs and is a conjunction of constraints, each being either a relation from or applied to some of the variables in . Now if , then we can think of as a instance with variables being , and this instance can be satisfied if and only , so we add (the constraints and the auxiliary variables of ) this instance to . If , but every is irreducible, then by Theorem 28, we may assume that does not contain and therefore we can still write it as an instance of and add it to .
-
For each and , let
Clearly, for every satisfying assignment to , we may define such that , and will be a satisfying assignment to with the same cost. In particular, this means that .
Now if we have a constant-factor approximation algorithm for , we can use it to obtain a solution such that for some constant independent of . In fact, we may assume , since every label not in has infinite cost. Take , then by construction is a satisfying assignment for , and
Thus we obtain a constant-factor approximation algorithm for as well.
We refer interested readers to the survey by Barto el al. [6] which contains a more detailed exposition on pp-interpretation (and its generalization pp-construction) in the context of decision CSPs.
4.2 Proof of Theorem 26
The proof contains two cases: either has unbounded width, or it has bounded width. We use the following characterization for bounded-widthness of constraint languages.
Theorem 31 ([5, 17]).
Let be a constraint language that contains all singleton relations. is not bounded width if and only if there exists some nontrivial finite abelian group such that pp-interprets in the first power using pp-definitions without equality.
Here being nontrivial means it has at least 2 elements, and is the set of relations 333Here denotes the sum of copies of . Note that this is a finite set of relations, since is a finite group. over .
In the unbounded-width case we shall use a reduction from the Nearest Codeword problem, and in the bounded-width case we reduce from the hypergraph vertex cover problem.
Definition 32.
In the Nearest Codeword problem over a finite field , we are given a matrix and a vector , and we are asked to find a vector such that and the number of nonzero entries in is minimized.
Definition 33.
In the -uniform hypergraph vertex cover problem, we are given a -uniform hypergraph (namely, each hyperedge is contains vertices), and our goal is to choose a minimum number of vertices so that from each hyperedge we have chosen at least one vertex.
The following theorems give the best known NP-hardness results for approximating these two problems.
Theorem 34 ([20, 13]).
The Nearest Codeword problem over any finite field is NP-hard to approximate within a factor of , for any constant .
Theorem 35 ([19]).
The -uniform hypergraph vertex cover problem is NP-hard to approximate within a factor of , for any and .
We remark that if we further assume the Unique Games Conjecture, then we can improve the hardness factor for -uniform hypergraph vertex cover from to [2], but this difference does not matter for us here.
The following is a simple corollary from the hardness of the Nearest Codeword problem.
Corollary 36.
Let be the set of all relations of the form 444Here denotes the multiplication between field elements . where over some finite field . Then is NP-hard to approximate within a factor of .
Proof.
We show how to cast the Nearest Codeword problem over as a instance. We first add the variables denoting entries of . For each , we impose a cost of 1 if it is not equal to , and 0 if it is equal to . This models the minimum Hamming weight requirement. To model the constraint , we first note that can also be used to simulate if one of is zero. This can be achieved as follows: to obtain the constraint , we create a dummy variable and add the constraint for an arbitrary nonzero , and then we set the non-zero label costs for to be all infinite and its zero label cost to be just 0, effectively forcing this variable to be zero. This can be extended easily if two of are zeros.
Now we need to transform each linear equation of the form so that left hand side contains at most 3 variables. This can be done via the standard trick: by introducing a new auxiliary variable (which has zero cost for any label), we may rewrite equivalently as and , and thereby reducing the number of variables on the left hand side by 1. We repeat this procedure until all equations have at most 3 variables on the left hand side. It is clear that the resulting instance is a instance which is equivalent to the original Nearest Codeword instance. By Theorem 34, we can therefore conclude that is also NP-hard to approximate within a factor of .
Lemma 37.
Let be a constraint language such that has a constant-factor approximation, then is bounded-width unless P = NP.
Proof.
We prove the contrapositive. Let be a constraint language with unbounded width. Without loss of generality, assume that contains all unary relations. Then by Theorem 31, there exists some nontrivial finite abelian group such that pp-interprets in the first power. In particular, pp-interprets the set of all irreducible relations in the first power. By Lemma 30, we have .
We now claim that contains as a special case for some prime . Note that must contain some cyclic subgroup of prime order: one may find this subgroup by taking a subgroup of prime order of some cyclic subgroup generated by a single nonzero element in . We may identify this subgroup of order with the finite field . Note that any relation over is irreducible if are all nonzero, so these relations are contained in . So we have that contains as a subproblem (where we set the cost of any label outside to be infinite). It follows that , and therefore , do not have a constant-factor approximation unless P = NP.
For the bounded-width case, we use the following reduction from the hypergraph vertex cover problem.
Lemma 38 ([18]).
Let be a bounded-width constraint language which is not preserved by any NU operation. If contains all unary singleton relations, then for every , there is a -ary relation pp-definable from and such that
Lemma 39.
Let be a bounded-width constraint language which is not preserved by any NU operation. Then does not have a constant-factor approximation unless P = NP.
Proof.
Assume that has all unary relations without loss of generality. Note that the -uniform hypergraph vertex cover problem is the MinCostCSP problem with a single relation , which is pp-definable from by Lemma 38 (by thinking of as 0 and as 1, and the assumption that as a unary relation is in ). Observe that is irreducible, so the reduction in Lemma 30 implies that is as hard to approximate as the -uniform hypergraph vertex cover problem, in particular, by Theorem 35, it is NP-hard to approximate within a factor of for any . Since can be arbitrarily large, this implies that does not have a constant-factor approximation, unless P = NP.
Theorem 26 can now be obtained by combining these two cases.
Proof of Theorem 26.
Let be a constraint language such that has a constant-factor approximation and assume that P NP, then by Lemma 37, must be bounded-width. It then follows from Lemma 39 that must be preserved by some NU operation.
Remark 40.
In the Boolean case (), it follows from Khanna et al.’s classification [30] as well as Post’s classification of Boolean clones [38] that the necessary condition of having a conservative NU polymorphism is sufficient as well. Recall that we have the following three classes of constant-factor approximable Boolean MinCostCSPs:
-
can be expressed as a 2CNF-formula. In this case, is preserved by the (unique) majority operation. (This case also includes constraint languages that are width-2 affine for which MinCostCSP can be solved to optimality.)
-
is expressible as a CNF formula where each clause is of the form , , or where for some depending on . In this case is preserved by the -ary NU operation , where
-
is expressible as a CNF formula where each clause is of the form , , or where for some depending on . In this case is preserved by the -ary NU operation .
It can be easily verified using Post’s Lattice [38] that any constraint language whose polymorphism clone contains an NU operation can be reduced to one of the three cases above. However, as soon as , the condition of being preserved by some NU operation is no longer sufficient (for example, see Theorem 45 in the following subsection).
4.3 A hard predicate with a majority polymorphism
We now present a binary relation which has a conservative majority polymorphism, but nonetheless is hard to approximate within any constant factor, unless UGC fails. This implies that the existence of an NU polymorphism is in general not sufficient for constant-factor approximability assuming UGC.
Definition 41.
Let be the binary relation on domain such that holds if and only if or .
The constraint satisfaction problem defined by is equivalent to the graph homomorphism problem to the undirected graph shown in Figure 2. Intuitively, is the XOR predicate with a “wildcard” element 2 such that the predicate is also satisfied if some input is 2.
We now verify that is preserved by a conservative majority operation.
Claim 42.
Let be defined as follows
Then .
Proof.
Let . We verify that . This is always true if at least one of and is 2. If neither is 2, then there is a majority in as well as in . It follows by the pigeonhold principle that there must be some such that is equal to the majority element in and is equal to the majority element in , so we have . Note that is conservative since when there isn’t a majority we must have .
To prove that is hard to approximate, we use a reduction from the Min UnCut problem.
Definition 43.
In the Min UnCut problem, the input is a weighted undirected graph where for every , and we are asked to remove a subset of the edges such that the remaining graph is bipartite. The goal is to minimize the total weight of removed edges .
We use to denote the value of an optimum solution to Min UnCut(). Without loss of generality, we may assume that the total edge weight in a Min UnCut instance is normalized to be 1, i.e., .
Theorem 44 ([32]).
Assuming UGC, there exists some constant such that for all sufficiently small it is NP-hard to distinguish instances of Min UnCut with value at most and instances with value at least . In particular, it is NP-hard to approximate Min UnCut within any constant factor, assuming UGC.
Theorem 45.
Assuming UGC, it is NP-hard to approximate within any constant factor.
Proof.
Given any Min UnCut instance , we construct an instance I of MinCostCSP() such that . This reduction combined with Theorem 44 will establish our theorem. The reduction is as follows. The variable set of will be where we take vertices in plus two distince auxiliary variables for every edge . For every , we add three constraints to (note that the order of and does not matter). For the cost function , we define , for every , and , for the auxiliary variables. This completes the construction. See Figure 3 for an illustration.
We claim that . We first show that . Take any optimal assignment for . We take the same assignment for the vertex variables in which generates no cost. For any edge that is satisfied by the assignment, we can set , and satisfy all three constraints with no cost. For any edge that is not satisfied, we can set and , satisfying all three constraints with cost . So we obtain an assignment for that has value .
The other direction can be shown similarly. First observe that for each edge we may assume at most one of the two auxiliary variables is set to 2. Also, since for any vertex variable we have , we may assume that no vertex variable is set to 2. Now if we take an optimal assignment for with these two assumptions, restricted to the vertex variables is a valid assignment for whose the total weight of violated edges is at most the cost of , which implies that .
5 Application: Dichotomy for MinCostCSP with permutation constraints
As an application of our results, we give a complete classification for where contains all permutation relations.
Definition 46.
A binary relation over is called a permutation relation if for some bijective .
Theorem 47 (Theorem 3 restated).
Let be a set of relations over such that it contains all permutation relations. Then is -approximable if is preserved by a conservative majority operation. Otherwise, if is not preserved by any conservative majority operation, then it is also not preserved by any conservative NU operation and is not constant-factor approximable, assuming P NP.
A constraint language that contains all permutation relations can be seen as a natural generalization of Boolean constraint languages that allow negation of variables. Our classification relies on the classification of homogeneous algebras. To state the result, we first need some definitions.
Definition 48.
An algebra consists of a set (called the universe) and a set of operations (called the basic operations) which are functions from finite powers of to . The symbols and arities of the basic operations are called the signature of . A term operation is an operation obtained by composition of operations in .
The set of all term operations of a given algebra form a clone (recall Definition 9). We denote this clone by . When consists of finitely many operations, we may also write in place of .
Definition 49.
Let and be two algebras with the same signature. A function is called a homomorphism from to , if commutes with all basic operations. That is, for every -ary function symbol in the signature, we have , where and are the functions represents in and respectively. When , we also say that is an automorphism.
Definition 50.
An algebra is called a homogeneous algebra if every bijection is an automorphism.
The following claim follows directly from the definition.
Claim 51.
Let be a constraint language which contains all permutation relations. Then is a homogeneous algebra.
The study of homogenous algebras was initiated by Marczewski [37], and a complete classification was first obtained by Marchenkov [36]. Dalmau used Marchenkov’s result to give a complete classification for decision CSP where the constraint language contains all permutation relations [15]. The following theorem is taken from [43] (see also [15]).
Theorem 52 (Theorem 5.9 in [43]).
Let be a finite domain such that . Let be a homogeneous algebra, then either the dual discriminator operation is a term operation, or its clone of term operations is equal to one of the followings:
-
, ,
-
for , .
-
for , .
Here is the clone of projection operations. is the switching operation, defined by
For , is the -ary near projection operation defined by
And finally, is the -ary operation defined by
The assumption is not essential. When , the above algebras are all distinct. When , some of these algebras become non-distinct, but the only exceptional case not covered by the classification above is the Klein 4-group (the unique 4-element group with exponent 2) with the operation . However, this is not a conservative operation so we may safely ignore it for our purpose.
We are now ready to prove Theorem 47.
Proof of Theorem 47.
First observe that if contains some majority function , then there must be some such that when are pairwise distinct: if not, then there exist distinct and two triples with pairwise distinct elements within each triple such that . Then, let be a permutation such that for every , does not preserve the permutation relation , which is a contradiction. By potentially permuting the input coordinates in , we get that the dual discriminator operation is also contained in , and therefore is -approximable by Theorem 1.
Now suppose does not contain a conservative majority function, then in particular it does not contain the dual discriminator operation. Note that since can be assumed to contain all unary operations (see Observation 7), every polymorphism of is conservative. It is easy to see that is not conservative. If , then is NP-complete. Furthermore, Dalmau [15] showed that if for some , then is also NP-complete. So by Theorem 52, the only remaining possibility is . However, as is observed by Dalmau [15], does not contain any NU operation, so by Theorem 26, there is no constant factor approximation for , assuming P NP.
References
- [1] Kirby A Baker and Alden F Pixley. Polynomial interpolation and the chinese remainder theorem for algebraic systems. Mathematische Zeitschrift, 143:165–174, 1975.
- [2] Nikhil Bansal and Subhash Khot. Inapproximability of hypergraph vertex cover and applications to scheduling problems. In International Colloquium on Automata, Languages, and Programming, pages 250–261. Springer, 2010. doi:10.1007/978-3-642-14165-2_22.
- [3] Libor Barto. The dichotomy for conservative constraint satisfaction problems revisited. In 2011 IEEE 26th Annual Symposium on Logic in Computer Science, pages 301–310. IEEE, 2011. doi:10.1109/LICS.2011.25.
- [4] Libor Barto. The collapse of the bounded width hierarchy. Journal of Logic and Computation, 26(3):923–943, 2014.
- [5] Libor Barto and Marcin Kozik. Constraint satisfaction problems solvable by local consistency methods. Journal of the ACM (JACM), 61(1):1–19, 2014. doi:10.1145/2556646.
- [6] Libor Barto, Andrei Krokhin, and Ross Willard. Polymorphisms, and How to Use Them. In Andrei Krokhin and Stanislav Zivny, editors, The Constraint Satisfaction Problem: Complexity and Approximability, volume 7 of Dagstuhl Follow-Ups, pages 1–44. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 2017. doi:10.4230/DFU.Vol7.15301.1.
- [7] VG Bondarchuk, LA Kaluzhnin, VN Kotov, and BA Romov. Galois theory for post algebras. i-ii. Kibernetika, 3:1–10, 1969.
- [8] Joshua Brakensiek, Neng Huang, Aaron Potechin, and Uri Zwick. On the mysteries of max nae-sat. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 484–503. SIAM, 2021. doi:10.1137/1.9781611976465.30.
- [9] Joshua Brakensiek, Neng Huang, Aaron Potechin, and Uri Zwick. Separating max 2-and, max di-cut and max cut. In 2023 IEEE 64th Annual Symposium on Foundations of Computer Science (FOCS), pages 234–252. IEEE, 2023. doi:10.1109/FOCS57990.2023.00023.
- [10] Andrei A. Bulatov. Tractable conservative constraint satisfaction problems. In 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings., pages 321–330. IEEE, 2003.
- [11] Andrei A. Bulatov. Conservative constraint satisfaction re-revisited. Journal of Computer and System Sciences, 82(2):347–356, 2016. doi:10.1016/J.JCSS.2015.07.004.
- [12] Andrei A Bulatov. A dichotomy theorem for nonuniform csps. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 319–330. IEEE, 2017. doi:10.1109/FOCS.2017.37.
- [13] Qi Cheng and Daqing Wan. A deterministic reduction for the gap minimum distance problem. IEEE Transactions on Information Theory, 58(11):6935–6941, 2012. doi:10.1109/TIT.2012.2209198.
- [14] Martin C. Cooper, David A. Cohen, and Peter G. Jeavons. Characterising tractable constraints. Artificial Intelligence, 65(2):347–361, 1994. doi:10.1016/0004-3702(94)90021-3.
- [15] Victor Dalmau. A new tractable class of constraint satisfaction problems. Annals of Mathematics and Artificial Intelligence, 44:61–85, 2005. doi:10.1007/S10472-005-1810-9.
- [16] Víctor Dalmau, Marcin Kozik, Andrei Krokhin, Konstantin Makarychev, Yury Makarychev, and Jakub Oprsal. Robust algorithms with polynomial loss for near-unanimity csps. SIAM Journal on Computing, 48(6):1763–1795, 2019. doi:10.1137/18M1163932.
- [17] Víctor Dalmau and Andrei Krokhin. Robust satisfiability for csps: Hardness and algorithmic results. ACM Transactions on Computation Theory (TOCT), 5(4):1–25, 2013. doi:10.1145/2540090.
- [18] Víctor Dalmau, Andrei Krokhin, and Rajsekar Manokaran. Towards a characterization of constant-factor approximable finite-valued csps. Journal of Computer and System Sciences, 97:14–27, 2018. doi:10.1016/J.JCSS.2018.03.003.
- [19] Irit Dinur, Venkatesan Guruswami, Subhash Khot, and Oded Regev. A new multilayered pcp and the hardness of hypergraph vertex cover. SIAM Journal on Computing, 34(5):1129–1146, 2005. doi:10.1137/S0097539704443057.
- [20] I Dumer, D. Micciancio, and M. Sudan. Hardness of approximating the minimum distance of a linear code. IEEE Transactions on Information Theory, 49(1):22–37, 2003. doi:10.1109/TIT.2002.806118.
- [21] Alina Ene, Jan Vondrak, and Yi Wu. Local distribution and the symmetry gap: Approximability of multiway partitioning problems. arXiv preprint, 2015. arXiv:1503.03905.
- [22] Tomás Feder and Moshe Y Vardi. The computational structure of monotone monadic snp and constraint satisfaction: A study through datalog and group theory. SIAM Journal on Computing, 28(1):57–104, 1998. doi:10.1137/S0097539794266766.
- [23] David Geiger. Closed systems of functions and predicates. Pacific journal of mathematics, 27(1):95–100, 1968.
- [24] Dan Gusfield and Leonard Pitt. A bounded approximation for the minimum cost 2-sat problem. Algorithmica, 8(1):103–117, 1992. doi:10.1007/BF01758838.
- [25] Gregory Gutin, Pavol Hell, Arash Rafiey, and Anders Yeo. A dichotomy for minimum cost graph homomorphisms. European Journal of Combinatorics, 29(4):900–911, 2008. doi:10.1016/J.EJC.2007.11.012.
- [26] Pavol Hell, Monaldo Mastrolilli, Mayssam Mohammadi Nevisi, and Arash Rafiey. Approximation of minimum cost homomorphisms. In Algorithms–ESA 2012: 20th Annual European Symposium, Ljubljana, Slovenia, September 10-12, 2012. Proceedings 20, pages 587–598. Springer, 2012. doi:10.1007/978-3-642-33090-2_51.
- [27] Pavol Hell and Arash Rafiey. The dichotomy of minimum cost homomorphism problems for digraphs. SIAM Journal on Discrete Mathematics, 26(4):1597–1608, 2012. doi:10.1137/100783856.
- [28] Peter Jeavons, David Cohen, and Martin C Cooper. Constraints, consistency and closure. Artificial Intelligence, 101(1-2):251–265, 1998. doi:10.1016/S0004-3702(98)00022-8.
- [29] Peter Jonsson and Gustav Nordh. Introduction to the maximum solution problem. Complexity of Constraints: An Overview of Current Research Themes, pages 255–282, 2008. doi:10.1007/978-3-540-92800-3_10.
- [30] Sanjeev Khanna, Madhu Sudan, Luca Trevisan, and David P Williamson. The approximability of constraint satisfaction problems. SIAM Journal on Computing, 30(6):1863–1920, 2001. doi:10.1137/S0097539799349948.
- [31] Subhash Khot. On the power of unique 2-prover 1-round games. In Proceedings of the thiry-fourth annual ACM symposium on Theory of computing, pages 767–775, 2002. doi:10.1145/509907.510017.
- [32] Subhash Khot, Guy Kindler, Elchanan Mossel, and Ryan O’Donnell. Optimal inapproximability results for MAX-CUT and other 2-variable CSPs? SIAM Journal on Computing, 37(1):319–357, 2007. doi:10.1137/S0097539705447372.
- [33] Subhash Khot and Oded Regev. Vertex cover might be hard to approximate to within 2- . Journal of Computer and System Sciences, 74(3):335–349, 2008.
- [34] Andrei Krokhin and Stanislav Zivny. The Complexity of Valued CSPs. In Andrei Krokhin and Stanislav Zivny, editors, The Constraint Satisfaction Problem: Complexity and Approximability, volume 7 of Dagstuhl Follow-Ups, pages 233–266. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 2017. doi:10.4230/DFU.Vol7.15301.233.
- [35] Amit Kumar, Rajsekar Manokaran, Madhur Tulsiani, and Nisheeth K Vishnoi. On lp-based approximability for strict csps. In Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1560–1573. SIAM, 2011. doi:10.1137/1.9781611973082.121.
- [36] S.S. Marchenkov. Homogeneous algebras. Problemy Kibernetiki, 39:85–106, 1982.
- [37] E. Marczewski. Homogeneous algebras and homogeneous operations. Fund. Math, 56(8):103, 1964.
- [38] E.L. Post. The two-valued iterative systems of mathematical logic. Annals of Mathematics Studies, 1941.
- [39] Akbar Rafiey, Arash Rafiey, and Thiago Santos. Toward a dichotomy for approximation of H-coloring. In 46th International Colloquium on Automata, Languages, and Programming (ICALP 2019), pages 91:1–91:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.ICALP.2019.91.
- [40] Prasad Raghavendra. Optimal algorithms and inapproximability results for every csp? In Proceedings of the fortieth annual ACM symposium on Theory of computing, pages 245–254, 2008. doi:10.1145/1374376.1374414.
- [41] Thomas J Schaefer. The complexity of satisfiability problems. In Proceedings of the tenth annual ACM symposium on Theory of computing, pages 216–226, 1978. doi:10.1145/800133.804350.
- [42] Hanif D Sherali and Warren P Adams. A hierarchy of relaxations between the continuous and convex hull representations for zero-one programming problems. SIAM Journal on Discrete Mathematics, 3(3):411–430, 1990. doi:10.1137/0403036.
- [43] Ágnes Szendrei. Clones in universal algebra. Presses de l’Université de Montréal, 1986.
- [44] Rustem Takhanov. A dichotomy theorem for the general minimum cost homomorphism problem. In 27th International Symposium on Theoretical Aspects of Computer Science (2010), pages 657–668. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2010. doi:10.4230/LIPICS.STACS.2010.2493.
- [45] Johan Thapper and Stanislav Živnỳ. The complexity of finite-valued csps. Journal of the ACM (JACM), 63(4):1–33, 2016. doi:10.1145/2974019.
- [46] Dmitriy Zhuk. A proof of the csp dichotomy conjecture. Journal of the ACM (JACM), 67(5):1–78, 2020. doi:10.1145/3402029.
