The Power of the Combined Basic LP and Affine Relaxation for Promise CSPs
Joshua Brakensiek, Venkatesan Guruswami, Marcin Wrochna, and Stanislav, \v{Z}ivn\'y

TL;DR
This paper introduces a polynomial-time algorithm for promise CSPs that admit infinitely many symmetric polymorphisms, extending previous work and unifying solutions for Boolean CSPs by leveraging symmetry properties.
Contribution
The authors develop a new algorithm that solves promise CSPs with symmetric polymorphisms, generalizing prior results and providing a complete characterization of its applicability.
Findings
The algorithm solves all promise CSPs with infinitely many symmetric polymorphisms.
It extends to block-symmetric polymorphisms, broadening its scope.
Block symmetric polymorphisms are both sufficient and necessary for the algorithm's success.
Abstract
In the field of constraint satisfaction problems (CSP), promise CSPs are an exciting new direction of study. In a promise CSP, each constraint comes in two forms: "strict" and "weak," and in the associated decision problem one must distinguish between being able to satisfy all the strict constraints versus not being able to satisfy all the weak constraints. The most commonly cited example of a promise CSP is the approximate graph coloring problem--which has recently seen exciting progress [BKO19, WZ20] benefiting from a systematic algebraic approach to promise CSPs based on "polymorphisms," operations that map tuples in the strict form of each constraint to tuples in the corresponding weak form. In this work, we present a simple algorithm which in polynomial time solves the decision problem for all promise CSPs that admit infinitely many symmetric polymorphisms, which are invariant…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsService-Oriented Architecture and Web Services · Business Process Modeling and Analysis · Scheduling and Optimization Algorithms
The Power of the Combined Basic LP and Affine
Relaxation for Promise CSPs††thanks: An extended abstract of part of this work (by the first two authors) appeared in the Proceedings of the 31st Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’20) [BG20].
Joshua Brakensiek Stanford University, Stanford, CA 94305, USA. Email: [email protected]. Research supported in part by an REU supplement to NSF CCF-1526092 and a NSF Graduate Research Fellowship.
Venkatesan Guruswami Computer Science Department, Carnegie Mellon University, Pittsburgh, PA 15213. Email: [email protected]. Research supported in part by NSF grants CCF-1814603 and CCF-1908125.
Marcin Wrochna University of Oxford, UK. Email: [email protected]. Research supported by funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 714532).
Stanislav Živný University of Oxford, UK. Email: [email protected]. Research supported by a Royal Society University Research Fellowship and by funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 714532).
Abstract
In the field of constraint satisfaction problems (CSP), promise CSPs are an exciting new direction of study. In a promise CSP, each constraint comes in two forms: “strict” and “weak,” and in the associated decision problem one must distinguish between being able to satisfy all the strict constraints versus not being able to satisfy all the weak constraints. The most commonly cited example of a promise CSP is the approximate graph coloring problem—which has recently seen exciting progress [BKO19, WŽ20] benefiting from a systematic algebraic approach to promise CSPs based on “polymorphisms,” operations that map tuples in the strict form of each constraint to tuples in the corresponding weak form.
In this work, we present a simple algorithm which in polynomial time solves the decision problem for all promise CSPs that admit infinitely many symmetric polymorphisms, which are invariant under arbitrary coordinate permutations. This generalizes previous work of the first two authors [BG19]. We also extend this algorithm to a more general class of block-symmetric polymorphisms. As a corollary, this single algorithm solves all polynomial-time tractable Boolean CSPs simultaneously. These results give a new perspective on Schaefer’s classic dichotomy theorem and shed further light on how symmetries of polymorphisms enable algorithms. Finally, we show that block symmetric polymorphisms are not only sufficient but also necessary for this algorithm to work, thus establishing its precise power.
1 Introduction
A central challenge in the theory of algorithms is to understand the mathematical structure (or lack thereof) that governs the efficient tractability (or intractability) of a computational problem. For the class of constraint satisfaction problems (CSP), a rich algebraic theory culminating in the recent resolution of the Feder-Vardi dichotomy conjecture [FV98] in [Bul17, Zhu17] has established a striking link between problem structure and its tractability. In particular, a CSP is efficiently solvable if and only if its defining relations admit an “interesting” polymorphism. Informally, a polymorphism is a function whose component-wise action preserves membership in the relations defining the CSP, and “interesting” means that the function obeys some non-trivial identities. As an example, for the (efficiently solvable) CSP corresponding to linear equations over a ring , the -ary function is a polymorphism (capturing the fact that if are solutions to a linear system, then so is ), and it obeys the so-called Mal’tsev identity for all . Indeed, generalizing Gaussian elimination, any CSP with such a Mal’tsev polymorphism is efficiently tractable [Bul02, BD06].
Recently, an exciting new direction of study has emerged in the rich backdrop of the complexity dichotomy for CSPs. This concerns a vast generalization of the CSP framework to the class of promise constraint satisfaction problems (PCSP). In a promise CSP, each constraint comes in two forms: “strict” and “weak.” Given an instance of a PCSP, one must distinguish between being able to satisfy all the strict constraints versus not being able to satisfy all the weak constraints. (This is the decision version; in the search version, given an instance with a promised assignment satisfying the strong form of the constraints, one seeks an assignment satisfying the weak form of the constraints.) A prime example of a PCSP is the approximate graph coloring problem, where one seeks to color a graph using more colors than its chromatic number.
The formal study of promise CSPs originated in [AGH17] who classified the complexity of a PCSP called -SAT. They further defined an extension of polymorphisms to the promise setting and postulated that the structure of those polymorphisms might govern the complexity of a PCSP. (This extension of polymorphisms to the promise setting is quite natural, requiring that the operation map tuples obeying the strict form of a constraint to a tuple satisfying its weak form.) Building on the impetus of [AGH17], Brakensiek and Guruswami systematically studied PCSPs under the polymorphic lens and established promising links to the universal-algebraic framework developed for CSPs [BG18, BG19]. It emerged from these works that a rich enough family of polymorphisms leads to efficient algorithms, whereas severely limited polymorphisms are a prescription for hardness. However, unlike for CSPs, there is no sharp transition between these cases — the significant difficulty being that, unlike for CSPs, polymorphisms for PCSPs are not closed under composition and lack the rich algebraic structure of a clone (c.f., [BKW17]). This nascent algebraic theory for PCSPs was lifted to a more abstract level in [BKO19, BBKO19] and also led to concrete breakthroughs in approximate graph coloring/homomorphisms [BKO19, KO19, WŽ20]. In particular, while previous works [BG18, BG19] focused on the actual form of the polymorphisms, the results of [BKO19] reveal that it is not the polymorphisms themselves, but rather solely the identities they satisfy, that capture the complexity of the associated PCSP, extending a similar phenomenon known earlier for CSPs [BOP18].
This work concerns the theme of designing algorithms for PCSP based on a rich enough family of polymorphisms. Our main result is that the decision version of an arbitrary PCSP admitting an infinite family of symmetric polymorphisms — i.e., polymorphisms which are invariant under any permutation of inputs — is tractable (see Theorem 2). Our result also extends to the case of block-symmetric polymorphisms (see Theorem 3). That is, the coordinates can be partitioned into “blocks” such that the function is invariant under permutations within each block. Notably, in the block-symmetric case the algorithm is identical–only the analysis changes. Furthermore, the number of blocks is irrelevant, the only assumption we need is that the minimum block size can be made arbitrarily large. Our final result (Theorem 4) shows that block-symmetry is not only sufficient but also necessary for our algorithm to work. In fact, Theorem 4 also establishes that without loss of generality one can assume that there are only two blocks of symmetric coordinates.
Further our algorithm is very simple — it checks if the canonical linear programming (LP) relaxation of the PCSP is feasible, and if so, it further checks if a slight adaptation of a canonical affine relaxation is feasible. The algorithm outputs satisfiable if both these relaxations are feasible. The polymorphisms are not used in the algorithm itself and only enter the analysis. The analysis is short but subtle — if we had symmetric polymorphisms of all arities then it is known that the basic LP relaxation itself correctly decides satisfiability, as one can round the fractional solution to a satisfying assignment using the polymorphism after clearing denominators of the fractional solution [KOT*+*12, BKW17]. If polymorphisms only exist of certain arities (e.g., all odd majorities), then the LP alone doesn’t suffice (e.g., [KOT*+*12]). We solve a linear system over the integers corresponding to the affine relaxation which lets us adjust the LP solution to match the arity at which a polymorphism exists. As a subtle twist, the affine relaxation is not of the original PCSP, but rather a refinement of the CSP which results from throwing out assignments to constraints which were ruled out by the basic LP.
It should be pointed out that we only solve the decision version of the PCSP, and not the search version. Unlike CSPs, for promise CSP there is no known reduction from search to decision, even for special cases like approximate graph coloring. Our work might be indicative of the subtle relationship between the search and decision problems for promise CSPs.
We now compare our result here with the previous work [BG19] where an algorithm was given to solve (the search version of) any PCSP that admits an infinite family of structured symmetric polymorphisms. Examples of such structured families include threshold and threshold-periodic polymorphisms. The value of a threshold polymorphism (for a Boolean PCSP) depends on whether the fraction of s in the input belongs in a finite number of intervals. (A basic example consists of Majority functions of odd arities, which are polymorphisms for 2-SAT.) A threshold-periodic polymorphism can have a periodic behavior depending on which interval the Hamming weight belongs to — for example it can be Majority for relative weights in and parity outside this interval. More generally, one can generalize to the non-Boolean case, as well as for the block-symmetric case, via regional polymorphisms whose value depends on the geometric region in which the vector of frequencies of the inputs to the polymorphisms lies. Due to this geometric interpretation, [BG19] assumes a fixed number of blocks (corresponding to a fixed dimension), whereas our new algorithm and analysis is independent of the number of blocks. The algorithm was a combination of solving the LP relaxation (albeit over a special ring like rather than the rationals) and the affine relaxation over a large enough finite ring. The analysis relied on the special structure of the polymorphisms (beyond their full symmetry). In contrast, our result here is more general, and only requires the polymorphism to be a symmetric function — its exact specifics or structure do not matter. It is encouraging that our methodology is consistent with the algebraic result in [BKO19] that the symmetries possessed by the polymorphisms capture the complexity of the PCSP.
Our result and methods have significance even for normal (non-promise) CSPs. For instance, we get a single unified algorithm to solve all non-trivial tractable cases of Boolean CSPs in Schaefer’s classic dichotomy theorem [Sch78], namely 2-SAT, Horn-SAT (or its dual), and Mod-2 Linear Equations. The two main techniques to solve CSPs are local propagation based algorithms (which work for the so-called bounded-width CSPs [BK14, KOT*+*12], etc.) and Gaussian elimination (which is a global algorithm that works for linear equations). The major difficulty in proving the full CSP dichotomy was tackling the complicated ways in which these two very different algorithms might need to be interlaced to solve a general CSP. It is our hope that this work serves as an impetus toward the potential discovery of a more modular CSP algorithm that incorporates together linear programming or its extensions (like Sherali-Adams, or semidefinite programming) and linear equation solving. In this light, it is encouraging that full symmetry of the polymorphisms, which is indeed a strong assumption, is not the limit of our techniques, which also extend to the block-symmetric case.
To put this work in further context, except for [BG19] as mentioned previously, nearly all works in the PCSP literature [AGH17, BG18, FKOS19] focus primarily on the structure of the relations. In particular, [BG18, FKOS19] characterized the complexity of all Boolean symmetric relations (rather than symmetric polymorphisms) which encompass many of the known tractable cases of Boolean PCSP. As classified by [FKOS19], all the relevant tractable polymorphisms are either symmetric functions or one special case of block-symmetric known as alternative threshold (and variants). Thus, in the context of PCSPs, the algorithm in this paper supersedes these previous works. See Section 4 for further discussion.
2 Notation
We let any finite set or denote a domain. A relation is a subset for any positive integer ; we denote . We define a signature to be a set of symbols such that each has a positive integer arity .
A relational structure with signature , denoted by , is an indexed set of relations over . A homomorphism between structures and with the same signature is a map such that for all (where is applied to a tuple component-wise).
Two relational structures for which there exists a homomorphism from the first to the second is called a promise template and is denoted as .
2.1 PCSP: Decision and Search
Consider a promise template with signature . An instance of the promise constaint satisfaction problem consists of a set of variables , and a set of constraints , where , where is a symbol in and is a tuple of arity . We say that is satisfiable in if one can assign to every variable () a value in the domain so that for every constraint (), the tuple (with applied component-wise) is in . Equivalently, can be described as a relational structure with domain and relations ; a satisfying assignment is then the same as a homomorphism from to . If is satisfiable in , then it is satisfiable in (because the satisfying assignment can be composed with the homomorphism from to ).
We let denote the decision problem of distinguishing instances satisfiable in from those unsatisfiable in (with the promise that the input instance falls into one of these two disjoint cases). We let denote the search problem of finding an explicit homomorphism from to , with the promise that a homomorphism from to exists.
2.2 Polymorphisms
A polymorphism of of arity is a map such that for all , where we define the latter to be In other words, consider any matrix , where each row is a satisfying assignment in . Let be the result of applying to each column of . Then, . We let denote the set of polymorphisms of (of all arities).
A map is said to be symmetric if for all (the symmetric group on elements), .
2.3 Basic LP and Affine Relaxation
As is well-studied in the CSP literature (e.g., [RS09, TŽ17]), we consider the canonical linear programming relaxation of a CSP instance, often referred to as the “Basic LP” or “BLP.” For our CSP instance , we represent the assignment of a variable by a (rational) probability distribution of weights summing to . We also have a probability distribution over the satisfying assignments to each constraint, which we denote as , where is the index of the constraint and is the potential assignment. Finally, the marginal distribution of a variable in any constraint has to equal . Explicitly, the linear constraints are as follows.
[TABLE]
Here denotes that setting sets (that is, if is the -th variable of the tuple , then ). We let denote the rational polytope of solutions. By a theorem of [GLS93] (c.f., [BG19]), we can efficiently find a relative interior point in this polytope. In particular, at such a point, each coordinate is positive if and only if it is positive at some point in the polytope.111For our specialized LP, we do not need such a hammer. We can instead solve the LP repeatedly, each time maximizing a different variable as the objective function–a similar idea appears in [BG18]. Averaging the results would then yield a solution such that each variable is positive if and only if it is positive in some LP solution.
In addition to the Basic LP, we also consider the affine relaxation of a Promise CSP. In essence we solve the same linear system, but instead of enforcing each variable to be a nonnegative rational, we enforce that it is an integer (possibly negative). This can be solved in polynomial time via [KB79] (see also [BG19] for a more detailed discussion of this approach). We let replace for all and replace for all . Explicitly,
[TABLE]
We let denote the integral lattice of solutions.
3 BLP+Affine Algorithm and Analysis for Symmetric Polymorphisms
In the BLP+Affine algorithm, given an instance of , we seek to throw out any assignment to a constraint for which the LP determines to have weight [math]. That is, given a relative interior point of , we refine to by requiring to be zero whenever is, and requiring to be zero whenever is (by adding equations or just removing those variables from equations defining ).
The algorithm is presented in Figure 1. Note it does not depend on ; it is only relevant for the correctness proof.
Definition 1**.**
We say the BLP+Affine algorithm correctly solves if it accepts any instance satisfiable in and rejects any instance unsatisfiable in .
As stated in the introduction, both the algorithm and the proof are structured similarly to those of [KOT*+*12] and [BG19]. Like in those works, the weights of the LP solution and affine relaxation are used to construct a list of assignments which are plugged into the relevant polymorphism. The novel contribution here is that a single argument can cover any infinite symmetric family of polymorphisms.
Theorem 2**.**
Let be a promise template (over any finite domain) such that has symmetric polymorphisms of arbitrarily large arities. Then, the BLP+Affine algorithm correctly solves .
Proof.
If an instance is satisfiable in , then the Basic LP relaxation has a solution. The refinement includes every possible assignment which is in the support of some LP solution, including integral solutions. Thus it is non-empty and therefore the algorithm accepts.
Conversely, suppose the algorithm accepts, meaning both and have solutions over and over . The latter is a solution of such that
[TABLE]
We claim is satisfiable in . Among all the coordinates in the LP solution–the ’s and ’s–let be the least common denominator of these rational numbers. Let be the maximum absolute value of any integer which appears in the affine solution (both the variable weights and the constraint weights ). Let be a symmetric polymorphism of arity Now write where and . Note that .
For each and , let
[TABLE]
This is an integer by choice of . For a fixed , note that by Eq. (3) and (6)
[TABLE]
Also, for fixed and , either , which implies that by the refinement, so . Otherwise, , so
[TABLE]
That is, for are non-negative integers which sum to . We claim that the assignment
[TABLE]
to defines a satisfying assignment of in . (Since is symmetric, only the quantity of each in the input matters.) To verify it is indeed satisfying, consider a constraint in (with ) and assume without loss of generality it is on variables . We claim .
For every valid assignment to that constraint in , define
[TABLE]
By similar logic as before, these are non-negative integers that sum to 1. Indeed, by Eqs. (4) and (7),
[TABLE]
Moreover, either , implying , or
[TABLE]
Further note that by Eqs. (5) and (8),
[TABLE]
For each consider a matrix , where exactly of the rows are equal to . For all and , the number of times that appears in column is precisely by Eq. (9). Thus, applied to the columns is precisely . Since is a polymorphism, this implies . This concludes the proof that assigning the value to each variable (for ) satisfies in and hence that the algorithm is correct. ∎
Remark. Another algorithm which works is to solve (that is the constrained variables are over non-negative elements of the ring ) using the algorithm from [BG19], instead of . In this case, Steps 2 and 3 can be omitted. To sketch why this works, it suffices to justify why solving also solves and . For each assigned value of the form in a relative interior solution to , consider changing this variable to , where is a sufficiently good rational approximation of . Such an assignment is in the relative interior of as any inequality non-trivially involving , in particular (1), (2), is not tight due to being irrational. To see why is also satisfied, replace each assigned value of with . By inspection, this assignment (when changing ’s to ’s and ’s to ’s) satisfies . It also satisfies because with and integral implies .
4 Extension of Analysis to Block Symmetric Polymorphisms
We say that a map . is block-symmetric if there exists a partition of the coordinates of into blocks such that is permutation-invariant within each coordinate block . We define the width of to be the minimum size of any block.222Note that a function might have different partitions into symmetric blocks; we define the width to be the maximum width over all such partitions. In particular, every is block-symmetric with width at least 1. Finding the exact width or an appropriate partition into blocks is non-trivial. However, we avoid computing or evaluating altogether by only considering decision problems; see Section 6 for a discussion of search problems. A natural example of a block symmetric polymorphism with nontrivial width is alternating threshold first studied in [BG18]
[TABLE]
In this case, the blocks are the odd and even coordinates. This polymorphism arises in the context of corresponding to 1-in-3 SAT and corresponding to NAE-SAT. Recent work shows that this PCSP, although tractable and simple to state, is not algebraically reducible (via so-called pp-constructions) to any tractable finite-domain CSP [BBKO19].
We now show an analogue of Theorem 2 for block-symmetric polymorphisms. Remarkably, the algorithm is identical to the one for ordinary symmetric polymorphisms and is independent of the number of blocks. In particular, it could be that the Promise CSP has finitely many polymorphisms for any particular number of blocks, yet has infinitely many block-symmetric polymorphisms of increasing width.
As discussed in [BG19, FKOS19], nearly all known tractable Boolean PCSPs have polymorphisms which are either symmetric (such as threshold functions) or block-symmetric (such as alternating threshold). Thus, except for those PCSPs which are “homomorphic relaxations”333A homomorphic relaxation of a is another such that has a homomorphism to and to . In this case, trivially reduces to . In general, if is a Boolean template that is a homomorphic relaxation of a tractable non-Boolean (P)CSP template, then this is the only algorithm we know for . We leave as an open question finding an explicit Boolean PCSP which is a homomorphic relaxation of a non-Boolean CSP but not correctly solvable by our BLP+Affine algorithm. of a tractable (P)CSP (c.f., [BG19, BBKO19]), the algorithm presented here supersedes those works in the context of decision PCSP.
Theorem 3**.**
Let be a promise template (over any finite domain) such that has block-symmetric polymorphisms of arbitrarily large width. Then, the BLP+Affine algorithm correctly solves .
Proof.
The proof proceeds much like that of Theorem 2. As before, we know that if is satisfiable in , then the algorithm rejects. We seek to show that if the algorithm accepts, then is satisfiable in .
Again, let be the least common denominator of all coordinates in the LP solution. Let be the maximum absolute value of any integer which appears in the affine solution. Let be a block-symmetric polymorphism such that each block , with , has size at least . Let . Similar to before, for all , write where and . Note that .
We seek to show there exists a homomorphism from to . For each , and , let
[TABLE]
For a fixed and , by similar logic to the proof of Theorem 2, we have that are non-negative integers for all and
[TABLE]
We now claim that the assignment
[TABLE]
to defines a satifying assigment of in . To verify this, consider a constraint in (with ) and assume without loss of generality it is on variables . We claim . For all and assignments define
[TABLE]
By similar logic as previously, are non-negative integers and by Eqs. (4) and (7),
[TABLE]
Further note that by Eqs. (5) and (8) for and
[TABLE]
For each consider a matrix , where exactly of the rows are equal to in the rows indexed by block . For all and , the number of times that appears in column and row-block is precisely by Eq. (10). Thus, applied to the columns is precisely . Since is a polymorphism, this implies . This concludes the proof that the algorithm is correct. ∎
5 Characterizing the Algorithm’s Power
In this section, we characterize the power of the BLP+Affine algorithm from Figure 1 exactly. Recall, we denote the domains of relational structures as .
Theorem 4**.**
Let be a promise template. The following are equivalent:
- •
BLP+Affine algorithm correctly solves .
- •
* has block-symmetric polymorphisms of arbitrarily high width.*
- •
For every , has a block-symmetric polymorphism of arity with two symmetric blocks of variables of size and , respectively.
We need a few definitions and fundamental facts from [BKO19, BBKO19]. For an -ary function and a function , the minor of obtained from is the function defined as
[TABLE]
We write . Thus sets of polymorphisms are equipped with an operation which maps -ary polymorphisms to -ary polymorphisms (for every ). We consider such a structure more abstractly, allowing any objects to play the role of polymorphisms:
Definition 5**.**
A minion consists of sets for and functions for all functions , such that compositions agree: for , , and . We write for the disjoint union of , , and for . A minion homomorphism is a function which preserves arity and minors: and for all functions .
Note that the objects in a minion do not have to be functions, and the set does not have to be finite, though this is true for minions with finite . Similarly the operations are not necessarily defined by Eq. (11), though this will always be the case when elements of a minion are -ary function. As an important example, consider the minion of convex combination functions, i.e. functions of the form for , , with defined by Eq. (11). We can describe the same minion more concisely by identifying a convex -ary function with its -tuple of coefficients . That is, the “-ary objects” of the minion can be equivalently defined as distributions on :
[TABLE]
and for and one can define as
[TABLE]
This minion characterizes the power of the basic linear programming relaxation in the sense that BLP correctly solves (i.e. feasibility of implies is satisfiable in for all instances ) if and only if admits a minion homomorphism to . This was shown by Barto et al. [BBKO19, Theorem 7.9]. Our proof straightforwardly extends this part of the argument.
We first define the minion that plays the role of for the BLP+Affine relaxation. It assigns two coefficients to every coordinate .
Definition 6**.**
The minion is defined as follows: for , its “-ary objects” are
[TABLE]
Equivalently, these could be seen as a function from to
For and , we define the minor as , where
[TABLE]
It is easy to check this indeed defines a minion (the condition is preserved when taking a minor and composition of minors works as expected). One could also think of a pair as an -ary function on , .
The minion characterizes the BLP+Affine relaxation as follows.
Lemma 7**.**
Let be a promise template. The following are equivalent:
- •
BLP+Affine correctly solves (Definition 1).
- •
* admits a minion homomorphism to .*
As the proof of this lemma directly extends the arguments by Barto et al. [BBKO19], we refer the reader to Appendix A for an exposition of it.
We now reinterpret this last condition in terms of concrete polymorphisms. One direction is simple:
Lemma 8**.**
Suppose has a minion homomorphism to some minion . Then for every , contains a block-symmetric polymorphism of arity with two blocks of size and .
Proof.
Given , consider the following object : take and for . For every permutation which maps odd coordinates to odd coordinates (and even to even), . Thus the image of in has the same property, i.e. it has arity and it is symmetric on odd coordinates as well as on even coordinates. ∎
We remark the above lemma in fact applies to any minion , not only those of the form ; one can define to be block-symmetric with blocks if holds for all permutations of that preserve the blocks; the proof then applies without change.
The idea for the other direction is essentially the same as in the proof of Theorem 2 and 3. We apply it to construct a minion homomorphism from every finite subset of and use a compactness argument.
Lemma 9**.**
Suppose the minion (for finite) contains block-symmetric polymorphisms of arbitrarily high width. Then admits a minion homomorphism to .
Proof.
To avoid cumbersome notation we present the proof only for the case of one block, i.e. we assume that contains symmetric polymorphisms of arbitrarily high arity. This extends to more blocks just as Theorem 3 extends Theorem 2.
We define finite subsets of as follows. For , let be the subset of those such that for and . Observe that is a finite set (since the numbers are non-negative integers summing to and the numbers are integers between and ). Denote .
For fixed , we define a minion homomorphism from to as follows. Let be a function of some arity . Let be numbers such that , . Then .
Take and . For , the number is a non-negative integer. Since , we can map to the -ary minor of the -ary function where is repeated times, for . We claim that this map is a minion homomorphism from to (in fact to the subminion of minors of ). Indeed, for , consider the minor of identifying for into a single variable (for ). We have that is also a minor of where is repeated times. That is, is repeated times. By symmetry of the ordering does not matter, thus (the minor of the image of ) is the same as the image of the minor .
We conclude with a compactness argument similar to that of Remark 7.13 in [BBKO19]. For , let . Then is finite, (because implies ) and . Consider the possible minion homomorphisms from to , or more precisely, restrictions of homomorphisms obtained above to (since itself is technically not a minion). There are only finitely many possible such restrictions , because is finite, the arities of images in are bounded, and hence the number of possible images in is also finite. Consider an infinite tree with restrictions from any to as nodes, the trivial map from being the root, and the parent of a function being its restriction to . This is an infinite tree (because for each we have some minion homomorphism from a superset of to ) that is connected (because everyone is connected through its ancestors to the root) and finitely branching (because there are only finitely many restrictions , for any fixed ). Therefore, by Kőnig’s lemma, the tree contains an infinite path of homomorphisms that are restrictions of each other. Their union is then a homomorphism from to . ∎
(We remark the above proof in fact applies to any minion , assuming is finite for every .) Lemmas 7, 8, and 9 conclude the proof of Theorem 4.
6 Concluding Thoughts
We conclude with a few natural directions of future inquiry raised by this work.
Inspecting the proofs of Theorems 2 and 3, in order to yield a search algorithm (and not just a decision algorithm), it would suffice to compute:
[TABLE]
for some block-symmetric polymorphism and a fixed partition into blocks of size at least , for an integer which depends polynomially on the least common denominator of rational numbers in the LP solution and the maximum absolute value of integers in the affine solution. In previous work [BG19], Brakensiek and Guruswami circumvented this problem by assuming that has special structure (such as being a threshold function, etc.). Even then, we often only assumed that you had oracle access to the structure of . Thus, except for some simple cases studied in the paper, truly polynomial-time search algorithms remain elusive. Perhaps one could hope for a search algorithm like the decision algorithm presented in this paper which is oblivious to the underlying polymorphisms (as long as they are symmetric/block-symmetric).
Question. Is there an “oblivious” polynomial-time algorithm for the search version of Promise CSPs with infinitely many symmetric polymorphisms?
We note that an oblivious polynomial-time algorithm is also not known for the search version of Promise CSPs with symmetric polymorphisms of all arities (which capture the power of BLP [BBKO19, Theorem 7.9]) and for the search version of Promise CSPs with alternating polymorphisms of all odd arities (which capture the power of the affine relaxation [BBKO19, Theorem 7.19]).
Otherwise, one could hope to prove a “structure theorem” that every Promise CSP with infinitely many symmetric polymorphisms also has an infinite threshold-periodic family. As [BG19] shows, such polymorphisms can get exceedingly complicated, suggesting that such a characterization may only be possible in the Boolean case.
Question. Does every Boolean PCSP with infinitely many symmetric polymorphisms have an infinite threshold-periodic family?
Even without a structure theorem, one could perhaps hope to compute the pertinent values of “on the fly,” but this seems difficult in our current formulation as the arity of could be exponentially large in the input size!
While Theorem 4 characterizes the power of the BLP+Affine algorithm, it is still worthwhile to ask how this compares to other classes of templates, in particular those studied for non-promise CSPs. The following example of a simple template not solved by the BLP+Affine relaxation was communicated to us by Jakub Opršal.
Example 10**.**
Let be the disjoint union of a directed 2-cycle and a directed 3-cycle . Then is tractable template (i.e. is solvable in polynomial time, in fact has cyclic polymorphisms of every prime arity ) but has no non-trivial block-symmetric polymorphisms.
Proof.
To see it admits no block-symmetric polymorphisms of width greater than one, observe that every such width can be represented as for some , hence every block can be filled with copies of values and copies of , giving some input to . But should give the same output on the input consisting of copies of and copies of . Since is an arc of for every and since is a polymorphism, would be a loop in , a contradiction.
We now observe that has a straightforward polynomial time algorithm. For each connected component of constraints, the variables must map to either or . The first case is equivalent to testing if the graph of constraints is bipartite. The latter can be done by a breath-first search which checks that all directed cycles have length a multiple of . ∎
Thus the condition of having block-symmetric polymorphisms of high width is not preserved under disjoint union, even though tractability is. We also know that since has a majority polymorphism (simply let output if and otherwise), can be solved in polynomial time via the -consistency algorithm, 3-rounds of Sherali-Adams, or the canonical SDP relaxation (see also [BK14, TŽ17, BKW17]). Informally, these relaxations ensure that there are locally consistent assignments to every (constant-sized) subset of variables. This consistency is quite powerful. For instance, 2-SAT can be solved by the BLP+Affine relaxation or 3 rounds of Sherali-Adams, but not the BLP by itself. This suggests the tantalising possibility that an analogous hierarchy could provide a uniform algorithm for all tractable non-promise CSPs.
Question. Which (decision) promise CSPs can be solved via constantly many rounds of the Sherali-Adams hierarchy for the BLP+Affine relaxation? Does this capture all tractable non-promise CSPs?
Acknowledgments
We thank Libor Barto, Andrei Krokhin, and Jakub Opršal for useful comments and encouragement. We also thank anonymous reviewers for many helpful comments.
Appendix A From Relaxations to Minion Homomorphisms
In this appendix, we recall the definition of the minion and prove Lemma 7 from Section 5. We do this by explaining how free structures relate BLP and Affine relaxations to minions. We carry over the notation from Section 5.
Definition 11**.**
The minion is defined as follows: for , the “-ary object” of the minion are
[TABLE]
for and , we define the minor of as
[TABLE]
Let us describe how characterizes the power of the basic linear programming relaxation; the case of BLP+Affine will be entirely analogous. Recall that for an instance of , a solution to the BLP relaxation assigns to each variable a distribution with . It also assigns to each constraint of a distribution over satisfying assignments with sum 1. Finally, the relaxation requires that for a variable in a constraint of , the assignment of to has value , where the sum runs over all satisfying assignments of the constraint where the variable takes value .
In other words, , where maps a satisfying assignment to the value of variable in constraint . That is, , as an object of , is required to be the minor of obtained from . Thus the BLP relaxation of is satisfiable if and only if one can assign some to each variable so that the following holds for every constraint of : there is a such that for all variables in , . This can be phrased as the existence of a homomorphism from to the free structure , defined as follows.
Definition 12**.**
For a relational structure and a minion , the free structure is a template with domain (potentially infinite) and with the same signature as . For each relation of arity in , there is a relation of the same arity in defined as follows: are in the relation if there is some such that for each , . Here maps to its -th coordinate.
The above discussion shows that:
Observation 13**.**
The BLP relaxation of has a solution if and only if is satisfiable in .
Just as in Definition 1, we say that “BLP correctly solves ” if for every instance , feasibility of the implies satisfiability of in . (Note the other direction is always trivially true: if is satisfiable in , then the relaxation has a solution). Let us write if there exists a homomorphism from to (i.e. a satisfying assignment); we can now restate the definition.
Observation 14**.**
Let be a promise template. The following are equivalent:
- •
BLP correctly solves ;
- •
for every instance , implies .
Entirely analogously, we can restate what it means for BLP+Affine to solve a PCSP (Definition 1), by using the minion (Definition 6).
Observation 15**.**
Let be a promise template. The following are equivalent:
- •
BLP+Affine correctly solves ;
- •
for every instance , implies .
The resulting condition can be simplified by a standard compactness argument. That is, we use the following straightforward generalization of the de Bruijn–Erdős Theorem (see e.g. [Die16, Theorem 8.1.3] for a discussion and short proofs, [RTW17] for general relational structures).
Lemma 16** (Compactness for structures).**
Let be relational structures with infinite and finite. If every finite induced substructure of admits a homomorphism to , then so does .
That is, for a promise template and any minion , the following are equivalent:
- •
for every instance , implies ;
- •
.
A fundamental property of free structures is that the latter condition is equivalent to the existence of a minion homomorphism, as proved by Barto et al. [BBKO19, Lemma 4.4].
Lemma 17** ([BBKO19]).**
Let be a promise template and let be any minion. The following are equivalent:
- •
;
- •
there exists a minion homomorphism from to .
Altogether, this shows that BLP+Affine solves if and only if admits a minion homomorphism to . This concludes the proof of Lemma 7 in Section 5.
We remark that Barto et al. [BBKO19, Theorem 7.9] used the same argument to characterize the power of BLP for PCSPs.
Theorem 18** ([BBKO19]).**
Let be a promise template. The following are equivalent:
- •
BLP solves (as in Definition 1),
- •
,
- •
,
- •
* admits a minion homomorphism to ,*
- •
* contains symmetric polymorphisms of every arity.*
Our argument thus only differs in the equivalence of the last two bullets, an analogue of which is proved in Section 5. Finally, let us note that in [BBKO19, Theorem 7.19], the power of the Affine relaxation alone was similarly characterized by the minion , defined analogously to , except with integer coefficients (not necessarily non-negative): the -ary objects are such that .
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[AGH 17] Per Austrin, Venkatesan Guruswami, and Johan Håstad. (2+( ϵ italic-ϵ \epsilon ))-Sat Is NP-hard. SIAM J. Comput. , 46(5):1554–1573, 2017.
- 2[BBKO 19] Libor Barto, Jakub Bulín, Andrei Krokhin, and Jakub Opršal. Algebraic approach to promise constraint satisfaction. ar Xiv:1811.00970 [cs, math] , 2019.
- 3[BD 06] Andrei Bulatov and Víctor Dalmau. A Simple Algorithm for Mal’tsev Constraints. SIAM J. Comput. , 36(1):16–27, July 2006.
- 4[BG 18] Joshua Brakensiek and Venkatesan Guruswami. Promise Constraint Satisfaction: Structure Theory and a Symmetric Boolean Dichotomy. In Artur Czumaj, editor, Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2018, New Orleans, LA, USA, January 7-10, 2018 , pages 1782–1801. SIAM, 2018. Full version available as ECCC TR 16-183.
- 5[BG 19] Joshua Brakensiek and Venkatesan Guruswami. An Algorithmic Blend of L Ps and Ring Equations for Promise CS Ps. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms , SODA ’19, pages 436–455, Philadelphia, PA, USA, 2019. Society for Industrial and Applied Mathematics.
- 6[BG 20] Joshua Brakensiek and Venkatesan Guruswami. Symmetric polymorphisms and efficient decidability of PCS Ps. In Proceedings of the 31st Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’20) , pages 297–304. SIAM, 2020. ar Xiv:1907.04383.
- 7[BK 14] Libor Barto and Marcin Kozik. Constraint Satisfaction Problems Solvable by Local Consistency Methods. Journal of the ACM , 61(1):3:1–3:19, January 2014.
- 8[BKO 19] Jakub Bulín, Andrei Krokhin, and Jakub Opršal. Algebraic Approach to Promise Constraint Satisfaction. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing , STOC 2019, pages 602–613, New York, NY, USA, 2019. ACM.
