20241004/2311.10040v2.json

{
    "title": "A characterization of efficiently compilable constraint languages",
    "abstract": "A central task in knowledge compilation is to compile a\nCNF-SAT instance into a succinct representation\nformat that allows efficient operations such as testing satisfiability, counting, or enumerating all\nsolutions.\nUseful representation formats studied in this area range from ordered\nbinary decision diagrams (OBDDs) to circuits in decomposable negation normal\nform (DNNFs).",
    "sections": [
        {
            "section_id": "1",
            "parent_section_id": null,
            "section_name": "Introduction",
            "text": "One of the main aims of knowledge compilation is to encode\nsolution sets of computational problems into a succinct but usable\nform [DarwicheM02]. Typical target formats for this compilation\nprocess are different forms of decision\ndiagrams [Wegener00] or restricted classes of Boolean\ncircuits. One of the most general representation formats are circuits in\ndecomposable negation normal form (DNNF), which have been\nintroduced in [Darwiche01] as a compilation target for Boolean functions.\nRelated notions, which also rely on the central decomposability\nproperty, have been independently considered in databases [OlteanuZ15, Olteanu16] and\ncircuit complexity [RazSY08, AlonKV20]. Besides these, DNNF circuits and related\ncompilation classes have also been proven useful in areas like probabilistic inference [BroeckS17], constraint satisfaction [KoricheLMT15, BerkholzV23, AmilhastreFNP14, MateescuD06], MSO evaluation [AmarilliBJM17], QBF\nsolving [CapelliM19], to\nname a few.\nThe DNNF representation format has become a popular\ndata structure because it has a particularly good balance\nbetween generality and usefulness [DarwicheM02].\nThere has also been a large amount of practical work on compiling solution\nsets into DNNF or its fragments, see\ne.g. [LagniezM17, Darwiche04, MuiseMBH12, ChoiD13, OztokD15, KoricheLMT15]. In\nall these works, it assumed that the solutions to be compiled are\ngiven as a system of constraints, often as a set of disjunctive\nBoolean clauses, i.\u2009e., in conjunctive normal form (CNF).\nIn this setting, however, strong lower bounds are known: it was shown that\nthere are CNF-formulas whose representation as DNNF requires\nexponential\nsize [BovaCMS14, BovaCMS16, Capelli17, AmarilliCMS20]. The\nconstraints out of which the hard instances\nin [BovaCMS14, AmarilliCMS20, Capelli17] are constructed are very\neasy\u2014they are only monotone clauses of two variables. Faced with\nthese negative results, it is natural to ask if there are any classes\nof constraints that guarantee efficient compilability into DNNF.\nWe answer this question completely and prove a tight characterization for every constraint language .\nWe first examine the combinatorial property of strong blockwise decomposability and show that if a constraint language  has this\nproperty, any system of constraints over  can be compiled into\na DNNF representation of linear size within polynomial time.\nOtherwise, there are systems of\nconstraints that require exponential size DNNF representations. In the\ntractable case, one can even compile to the restricted fragment of\nfree decision diagrams (FDD) that are in general known to be\nexponentially less succinct than DNNF [Wegener00, DarwicheM02].\nWe also consider the important special case of so-called structured\nDNNF [PipatsrisawatD08] which are a generalization of the\nwell-known ordered binary decision diagrams [Bryant86]. We show\nthat there is a restriction of strong blockwise decomposability that\ndetermines if systems of constraints over a set  can be\ncompiled into structured DNNF in polynomial time. In the tractable case, we can in fact\nagain compile into a restricted fragment, this time ordered decision\ndiagrams (ODD).\nFurthermore, we separate both notions of constraint languages admitting\nstructured and only unstructured representations and thus give a complexity picture of\nthe tractability landscape. We also show that it is decidable, whether\na given constraint language strongly (uniformly) blockwise\ndecomposable (a question left open in the conference version [DBLP:conf/stacs/BerkholzMW24]).\nLet us stress that all our lower bounds provide unconditional size lower\nbounds on (structured) DNNFs and thus do not depend on unproven complexity assumptions."
        },
        {
            "section_id": "2",
            "parent_section_id": null,
            "section_name": "Preliminaries",
            "text": ""
        },
        {
            "section_id": "3",
            "parent_section_id": null,
            "section_name": "Blockwise decomposability",
            "text": "In this section we introduce our central notion of blockwise and\nuniformly blockwise decomposable constraints and formulate our main theorems that lead to a characterization of\nefficiently representable constraint languages.\nThe first simple insight is the following. Suppose two constraints\n and  with disjoint scopes are efficiently\nrepresentable, e.\u2009g., by a small ODD. Then their Cartesian product\n also has a small ODD: given an assignment , we just need\nto check independently whether  and , for\nexample, by first using the ODD for  and then using the\nODD for . Thus, if a constraint can be expressed as a\nCartesian product of two constraints, we only have to investigate\nwhether the two parts are easy to represent. This brings us to our\nfirst definition.\nLet  be a constraint and  be a partition of its scope.\nWe call  decomposable w.r.t.  if\n.\nA constraint  is indecomposable if it is only\ndecomposable w.r.t. trivial partitions  where\n or  for .\nNext, we want to relax this notion to constraints that are \u201calmost\u201d\ndecomposable. Suppose we have four relations  of arity \nand  of arity  and let  be two distinct domain\nelements. Let\nThe constraint  may now not be decomposable in any\nnon-trivial variable partition. However, after fixing values for  and  the\nremaining selection \nis\ndecomposable in  for any pair . Thus, an ODD could first read values for  and then use ODDs\nfor  and  if , ODDs for\n and  if , or reject\notherwise. This requires, of course, that  and\n, as well as  and , have small\nODDs over the same variable order. For FDDs and DNNFs, however, we would\nnot need this requirement on the variable orders.\nTo reason about the remaining constraints after two variables have been fixed, it is helpful to\nuse the following matrix notation. Let  be a\nconstraint and  be two variables in its scope. The selection\nmatrix  is the  matrix where the rows and\ncolumns are indexed by domain elements  and the entries are\nthe constraints\nLet  and  a constraint with\nconstraint relation\n The selection matrix in  and  is depicted below,\nwhere the first line and column\nare the indices from  and the matrix entries contain the\nconstraint relations of the corresponding constraints :\n\u220e\nA block in the selection matrix is a subset of rows  and columns . We also associate with a block  the\ncorresponding constraint\n.\nA selection matrix is a proper block matrix, if there exist\npairwise disjoint  and pairwise disjoint\n such that for all :\nThe selection matrix in Example 3  ###reference_### is a proper\nblock matrix with , , , .\n\u220e\nWe will make use of the following alternative characterization of\nproper block matrices.\nThe simple proof is similar to [DyerR13, Lemma 1].\nA selection matrix  is a proper block matrix\nif and only if it has no -submatrix with exactly one\nempty\nentry.\nLet  be a proper block matrix and ,  be the pairwise disjoint\nsets provided by the definition.\nA -submatrix  may intersect ,  or  blocks. If it intersects  blocks, then all  of the entries of  are empty.\nIf  intersects only one block, then either ,  or  entries are in that block and thus non-empty. So the number of empty entries in  is ,  or .\nIf  intersect two blocks, then exactly  of its entries lie in those blocks and are thus non-empty. So  has  empty entries in that case.\nOverall,  may have , , , or  empty entries, so it satisfies the claim.\nFor the other direction, we must show how to find the block\nstructure. Take one non-empty entry and reorder the rows to  and\ncolumns to \nsuch that this entry is in the first column and first row, and the\nfirst row (column) starts with  () non-empty entries followed by\nempty entries. Consider for all  the -submatrix indexed\nby  and . Since it does not have exactly\none empty entry, we get:\nIf  and , then .\nIf  and , then .\nIf  and , then .\nThus, we can choose  \nand proceed with the submatrix on rows  and columns  inductively.\n\u220e\nNow we can define our central tractability criterion for constraints\nthat have small ODDs, namely that any selection matrix is a proper\nblock matrix whose blocks are decomposable over the same variable partition\nthat separates  and .\nA constraint  is uniformly blockwise\ndecomposable in  if  is a proper block\nmatrix with partitions ,  and there is a partition  of  with  and  such that each block  is decomposable in . A constraint  is uniformly blockwise decomposable if it is uniformly decomposable in any pair .\nIn the non-uniform version of blockwise decomposability, it is allowed that the\nblocks are decomposable over different partitions. This property will\nbe used to characterize constraints having small FDD representations.\nA constraint  is blockwise decomposable\nin  if  is a proper block matrix with partitions\n,  and for each \nthere is a partition  of  with  and\n\nsuch that each block \nis decomposable in\n.\nA constraint  is blockwise decomposable\nif it is decomposable in any pair .\nNote that every uniformly blockwise decomposable relation is also\nblockwise decomposable. The next example illustrates that the converse\ndoes not hold.\nConsider the 4-ary constraint relations\nThen the selection matrix  of the constraint \nhas two non-empty blocks:\nThe first block \nis decomposable in  and , while the second block  is\ndecomposable in  and . Thus, the constraint is blockwise\ndecomposable in , but not uniformly blockwise decomposable.\n\u220e\nFinally, we transfer these characterizations to relations and constraint languages:\nA -ary relation  is (uniformly) blockwise decomposable, if the\nconstraint  is (uniformly) blockwise decomposable for\npairwise distinct variables .\nA constraint language  is (uniformly) blockwise decomposable\nif every relation in  is (uniformly) blockwise\ndecomposable.\nA constraint language  is strongly (uniformly) blockwise\ndecomposable\nif its co-clone  is (uniformly) blockwise\ndecomposable.\nNow we are ready to formulate our main theorems. The first one states that\nthe strongly uniformly blockwise decomposable constraint languages are\nprecisely those that can be efficiently compiled to a structured\nrepresentation format (anything between ODDs and structured\nDNNFs).\nLet  be a constraint language.\nIf  is strongly uniformly blockwise decomposable, then there is a polynomial\ntime algorithm that constructs an\nODD for a given CSP()-instance.\nIf  is not strongly uniformly blockwise decomposable,\nthen there is a family  of CSP()-instances such that any structured DNNF for  has size .\nOur second main theorem states that the larger class of strongly\nblockwise decomposable constraint languages captures CSPs that can be\nefficiently compiled in an unstructured format between FDDs and DNNFs.\nLet  be a constraint language.\nIf  is strongly blockwise decomposable, then there is a polynomial\ntime algorithm that constructs an\nFDD for a given CSP()-instance.\nIf  is not strongly blockwise decomposable,\nthen there is a family  of CSP()-instances such that any DNNF for  has size .\nMoreover, we will show that both properties (strong blockwise decomposability\nand strong uniform blockwise decomposability) are decidable\n(Theorem 8.1  ###reference_###) and that  for the relation  from\nExample 3  ###reference_### separates both notions (Theorem 8.4  ###reference_###)."
        },
        {
            "section_id": "4",
            "parent_section_id": null,
            "section_name": "Properties of the Decomposability Notions",
            "text": "In this section we state important properties about (uniform)\nblockwise decomposability.\nWe start by observing that these notions\nare closed under projection and selection."
        },
        {
            "section_id": "4.1",
            "parent_section_id": "4",
            "section_name": "Basic Properties",
            "text": "We start with some basic properties that will be useful throughout the rest of this paper.\nLet  be a blockwise decomposable, resp. uniformly blockwise decomposable, constraint and let , , and . Then the\nprojection  as well as the selection  are also\nblockwise decomposable, resp. uniformly blockwise decomposable.\nIf  is (uniformly) blockwise decomposable consider . First note that each entry  is non-empty if  is\nnon-empty. Thus,  is a proper block\nmatrix with the same block structure  and\n as . Furthermore, if a block  is decomposable in , then the corresponding\nblock  in  is decomposable in\n. It follows that  is\n(uniformly) decomposable.\nFor the selection \u201c\u201d first consider the case where  or\n. Then the selection matrix  is\na submatrix of  and hence (uniformly)\nblockwise decomposable if  was (uniformly)\nblockwise decomposable.\nIn case , the matrix \nhas the same block structure as  and its\nentries decomposable w.r.t. the same partitions. Hence  is also (uniformly) blockwise decomposable in the\npair .\n\u220e\nIf a constraint language  is strongly (uniformly) blockwise\ndecomposable, then its individualization  is also strongly (uniformly) blockwise decomposable.\nConsider a pp-formula defining\n where with Lemma 4.1  ###reference_### we may assume that the formula contains no projection. Then the formula can be rewritten as\n, where\n is a -formula. Since by assumption\n is (uniformly) blockwise decomposable, the same holds for\n by repeatedly applying the selection  and Lemma 4.1  ###reference_###.\n\u220e\nWe next show that when dealing with blockwise decomposable relations, we can essentially assume that they are binary. To this end, we define for every constraint  the set of binary projections\nLet us compute  for the 4-ary relation  from\nExample 3  ###reference_###, see\nFigure 1  ###reference_###. For the unary relations, observe\nthat every column in  can take all\nfour values , so the only unary relation in  is\n. The six possible binary projections lead\nto three different constraint relations:\nprojecting  to  and  yields the relation\n.\nprojecting  to  and  yields the relation\n.\nprojecting  to  and  yields the relation\n. \u220e\nFor blockwise decomposable constraints, binary projections do not change solutions in the following sense.\n{lemma}\nLet  be a blockwise decomposable constraint. Then\nWe assume w.\u2009l.\u2009o.\u2009g. that  contains \ndistinct variables and let . First observe that  by the definition of projections.\nFor the other direction, we let  and need to show . For this, we show by induction on :\nNote that the lemma follows from this claim by setting  and that the base case\n follows from the definition of . So let  and\nassume that (9  ###reference_###) holds for all  with . Fix an\narbitrary  with , let  be three variables in ,\nand set  for . By induction assumption we get\n, which\nimplies that there are  such that\n.\nLet . In order to show that , we consider the selection\nmatrix . Since we have that ,\n, and  are non-empty,\nthese entries lie in the same block, which is decomposable into some\npartition  of  with  and . Moreover,\n and . Decomposability implies that  which is\nthe same statement as .\n\u220e\nLet  be a constraint language. Then we define \nto be the constraint language consisting of all relations of arity at most  that are pp-definable over . Equivalently,  consists of all relations that are constraint relations of constraints in  for a relation . Observe that even though  is infinite, we have that  is finite, since it contains only relations of arity at most two.\nConsider again the relation  and its projections  and \nfrom Example 3  ###reference_###, 4.1  ###reference_### and\nFigure 1  ###reference_###.\nWe let  and want to compute . We\nfirst observe that instead of  we could use the two binary\nprojections  and , that is, for  we have . To see this, observe first that we have already seen in Example 4.1  ###reference_### that . For the other direction, we just have to express  as a pp-formula in  which we do by\nSo to compute  we can equivalently analyze  which is easier to understand. Note first that the only unary relation that is pp-defiable over  is , so we only have to understand binary relations. To this end, we assign a graph  to every -formula  where the variables are the variables of  and there is an edge between two variables  and  if there is a constraint  or  in . In the former case, we label the edge with , in the latter with . Note that an edge can have both labels. An easy induction shows the following: if two variables  are connected by a path whose edges are all labeled with , then in any solution in which  takes value ,  takes value  as well and the same statement is true for . Moreover, if  and  are not connected by such a path, then there is a solution in which  takes value  and  takes value  and vice versa. An analogous statement is true for  and  and paths labeled by .\nFrom these observations, it follows that the only binary relations\nthat are pp-definable over  and that is not already in\n are the equality relation  and the trivial relation .\nThus we get\n. \u220e\nThe following result shows that for strongly blockwise decomposable constraint languages, we may assume that all relations are of arity at most two.\nLet  be a strongly blockwise decomposable language. Then .\nWe first show that . For this, it suffices to show that . So consider a relation . By definition,  is in particular pp-definable over , so  which shows the first direction of the proof.\nFor the other direction, is suffices to show that . So let  of arity . For the constraint  we have by Lemma 4.1  ###reference_### that  where . Since the relations  are all in , this shows that  pp-definable over  which proves the claim.\n\u220e"
        },
        {
            "section_id": "4.2",
            "parent_section_id": "4",
            "section_name": "The Relation to Strong Balance",
            "text": "Next, we will show that blockwise decomposable relations allow for\nefficient counting of solutions by making a connection to the work of Dyer\nand Richerby [DyerR13]. To state their dichotomy theorem, we need the following\ndefinitions. A constraint  is\nbalanced (w.r.t. ), if the \nmatrix  defined by\n is a proper block matrix, where each block has rank one. A constraint language  is strongly\nbalanced if every at least ternary pp-definable constraint is balanced.\n[Effective counting dichotomy [DyerR13]]\nIf  is strongly balanced, then there is a polynomial time\nalgorithm that computes  for a given\nCSP()-instance .\nIf  is not strongly balanced, then counting solutions\nfor CSP()-instances is P-complete.\nMoreover, there is a polynomial time algorithm that decides if a given\nconstraint language \nis strongly balanced.\nOur next lemma\nconnects\nblockwise decomposability with strong balance and leads to a\nnumber of useful corollaries in the next section. We sketch the proof for the case\nEvery strongly blockwise decomposable constraint language is\nstrongly balanced.\n\nWe first sketch the proof for the case\nwhen  is ternary, before proving the general case\n{proofsketch}\nLet  be strongly blockwise decomposable and  a\npp-defined ternary constraint. Then the selection matrix  is a block\nmatrix, where each block  is decomposable in some\n, either  or . In any case, for the\ncorresponding block  in\n we have\n where  and . Thus, the block has rank 1.\nTo prove the general case of Lemma 4.2  ###reference_###, it will be convenient to\nhave a generalization of the selection matrix . So consider a relation  in variables  and domain . Then  is the -matrix whose rows are indexed by assignments , whose column are indexed by the assignments  and that have as entry at position  the constraint\nWe say that  is blockwise set-decomposable with respect to  and  if  is a proper block matrix and for every non-empty block , the selection  is decomposable such that no factor contains variables of  and . We say that  is blockwise set-decomposable if it is blockwise set-decomposable for all choices  of disjoint variable sets.\nLet  be a relation. Then  is blockwise set-decomposable if and only if it is blockwise decomposable.\nIf  is blockwise set-decomposable, then it is by definition also blockwise decomposable. It only remains to show the other direction. So assume that  is blockwise decomposable. We proceed by induction on . If , then  and  each consist of one variable, so there is nothing to show.\nNow assume that w.l.o.g. . Let  be the variables of  not in . We first show that for all choices of  the matrix  is a proper block matrix with the criterion of Lemma 3  ###reference_###. Consider assignments  such that , , . We have to show that  as well. Let  be one of the variables in  and let  denote the other variables in . Let  and  denote the restriction of  to  and , respectively. We have ,  and , so by induction , so in  all four entries lie in a block . By decomposability of , there are relations  such that  and analogously for the other entries of . Since  and , we have that  and  and thus also . It follows that  and thus  is a block matrix.\nIt remains to show that the blocks of  decompose. So let  and  be the index sets of a block in the matrix. Consider again  and let the notation be as before. Let . Then we have for all  that , so by induction we have that for every  there is a relation  and for every  there is a relation such that . Moreover, all  are in the same variables and the same is true for all the . If  is a variable of the , then  so we get the decomposition of the block in  directly. Otherwise, so if  is a variable of the , we have  where we get  from  by projecting away . Again, we get decomposability of the block and it follows that  is blockwise set-decomposable.\n\u220e\nThe following connection between balance and blockwise decomposability is now easy to show.\nEvery blockwise decomposable relation is balanced.\nLet  be blockwise decomposable. Let  be variable sets. We want to show that  is balanced. Let  be a block. Since, by Lemma 4.2  ###reference_### the relation  is blockwise set-decomposable, every entry of  can be written as  where the  and  and  are the relations given by the decomposability of . It follows directly that  is a rank- matrix which shows the lemma.\n\u220e\nLemma 4.2  ###reference_### is now a direct consequence of Lemma 4.2  ###reference_###."
        },
        {
            "section_id": "4.3",
            "parent_section_id": "4",
            "section_name": "Consequences of the Relation to Strong Balance",
            "text": "In this section, we will use Lemma 4.2  ###reference_### to derive useful properties of strongly blockwise decomposable languages.\nLet  be a strongly blockwise decomposable constraint\nlanguage.\nGiven a\n-formula  and a (possibly empty) partial\nassignment , the number  of solutions that extend\n can be computed in polynomial time.\nGiven a\npp-formula  over  and , the blocks\nof  can be computed in polynomial time.\nGiven a\npp-formula  over , the indecomposable factors\nof  can be computed in polynomial time.\nClaim 1  ###reference_i1### follows immediately from the combination of\nLemma 4.2  ###reference_### with Theorem 4.2  ###reference_###\nand the fact that strongly blockwise decomposable constraint\nlanguages are closed under selection\n(Corollary 4.1  ###reference_###). For Claim 2  ###reference_i2### let  for some -formula . To compute the blocks of , we can use Claim 1  ###reference_i1### to compute for every  and\n whether  and hence .\nTo prove Claim 3  ###reference_i3###, note that by Claim 2  ###reference_i2### we can\ncalculate the block structure of  for every variable pair\n. Consider the graph  with \nand edges between  and  if  has at least\ntwo non-empty blocks. If  for some  and ,\nthen  and  must appear in the same indecomposable factor of\n. Let  be the connected components of . All variables of one connected component must appear in the same factor, so  is indecomposable. We claim that\n.\nIt suffices to show  for one connected component ,\nsince this can be used iteratively to show the claim. We have that for\nany  and , the selection matrix\n has only one block, which can be decomposed into\n, with  and , so that\nSince , no variable from the same connected component\n can be in  and therefore\n.\nSince we can obtain such a decomposition for every  and , and the intersection of all these decompositions\ninduces a decomposition where  is separated from any , we get\nthat .\n\u220e\nWe close this section by stating the following property that applies only\nto uniformly decomposable constraints.\nLet  be a constraint that is uniformly blockwise decomposable in  and . Then there exist  and  with  such that\nFurthermore, if  is defined by a pp-formula  over a strongly\nuniformly blockwise decomposable , then  and\n can be computed from  in polynomial time.\nSince  is uniformly blockwise decomposable in  and , there exist  and  with  such that for all  we have\nWe will show (11  ###reference_###) for this choice of  and . First, if  satisfies , then by definition of projections, we have for every  that  satisfies , which yields the containment  of (11  ###reference_###). Now let . Since  we get  and thus\nNow\n implies that\n. Analogously,\n implies that\n. Thus we get\n\nand .\nWe now show how to find  and  in polynomial\ntime in  if given as pp-definition .\nTo this end, we first compute the block structure of  with Corollary 4.3  ###reference_###.2  ###reference_i2###. Let  these blocks. Then we compute for every  the indecomposable factors of the block  by applying Corollary 4.3  ###reference_###.3  ###reference_i3### to the formula  which we can do by Corollary 4.1  ###reference_###. Denote for every  the corresponding variable partition by .\nIt remains to compute a variable set  with  such that for all  we have that  is a factor of  and . To this end, observe that if there is an  and a set  that contains two variables , then either  and  must both be in  or they must both be in . This suggests the following algorithm: initialize . While there is an  and a set  such that there are variables  and , add  to . We claim that when the loop stops, we have a set  with the desired properties. First, observe that we have for all  that  is a factor of , because otherwise we would have continued adding elements. Moreover,  by construction. Finally, since a decomposition with the desired properties exists by what we have shown above, the algorithm will never be forced to add  to . This proves the claim and thus complete the proof of the lemma.\n\u220e"
        },
        {
            "section_id": "5",
            "parent_section_id": null,
            "section_name": "Algorithms",
            "text": ""
        },
        {
            "section_id": "5.1",
            "parent_section_id": "5",
            "section_name": "Polynomial time construction of ODDs for strongly uniformly blockwise decomposable constraint languages",
            "text": "The key to the efficient construction of ODD for uniformly\nblockwise decomposable constraints is the following lemma, which\nstates that any such constraint is equivalent to a treelike conjunction of binary projections\nof itself.\n[Tree structure lemma]\nLet  be a constraint that is\nuniformly blockwise decomposable. Then there is an undirected tree\n with vertex set  such that\nFurthermore,  can be calculated in polynomial\ntime in , if  is uniformly blockwise decomposable\nand given as pp-formula  over a strongly uniformly blockwise decomposable language .\nWe first fix  and  arbitrarily and apply\nLemma 4.3  ###reference_### to obtain a tri-partition (, , ) of\n such that . We add the edge  to .\nBy Lemma 4.1  ###reference_###,\n and  are uniformly blockwise\ndecomposable, so Lemma 4.3  ###reference_###\ncan be recursively applied on both projections. For (say)\n we fix , choose an arbitrary , apply Lemma 4.3  ###reference_###, and add the\nedge  to . Continuing this\nconstruction recursively until no projections with more than\ntwo variables are left yields the desired result.\n\u220e\nFrom the tree structure of Lemma 5.1  ###reference_###, we will construct small ODDs by starting with\na centroid, i.\u2009e., a variable whose removal splits\nthe tree into connected components of at most \nvertices each. From the tree structure lemma it follows that we can\nhandle the (projection on the) subtrees independently. A recursive\napplication of this idea leads to an ODD of size .\nLet  be a CSP()-instance and  the\ncorresponding -formula. By Lemma 5.1  ###reference_###\nwe can compute a tree  such that\n. By Corollary 4.3  ###reference_###.1  ###reference_i1### we can explicitly\ncompute, for each , a binary relation\n such that\n. Now we define\nthe formula\n and\nnote that . It remains to\nshow that such tree-CSP instances can be efficiently compiled to\nODDs. This follows from the following inductive claim, where for\ntechnical reasons we also add unary constraints  for\neach vertex  (setting  implies the theorem).\nLet  be a tree on  vertices and  be a formula. Then there is an order ,\ndepending only on , such that an ODD< of size at most  deciding  can be computed\nin .\nWe prove the claim by induction on . The case  is\ntrivial.\nIf  let  be\na centroid in this tree, that is a node whose removal splits the tree into\n\nconnected components ,\u2026,  of at most  vertices each. It is a classical result that every tree has at least one centroid [Jordan1869]. Let , \u2026,  be vectors of the variables\nin these components, so (, , \u2026,\n) partitions .\nLet  be the neighbors of  in . We want to branch on  and recurse on the connected components\n. To this end, for each assignment  we remove for each\nneighbor  those values that cannot be extended to . That\nis, .\nNow we let \nand observe that\nBy induction assumption, for each  there is an order\n of  such that each  has an\nODD of size  for .\nNow we start our ODD for  with branching on \nfollowed by the sequential combination of ODD, \u2026, ODD for each assignment\n to . This completes the inductive construction. Since\nits size is bounded by\n, the following easy\nestimations finish the proof of the claim (recall that ):"
        },
        {
            "section_id": "5.2",
            "parent_section_id": "5",
            "section_name": "Polynomial time construction of FDDs for strongly blockwise decomposable constraint languages",
            "text": "For blockwise decomposable constraints that are not uniformly blockwise\ndecomposable, a good variable order may depend on the values assigned\nto variables that are already chosen, so it is not surprising that the\ntree approach for ODDs does not work in this setting.\nFor the construction of the FDD, we first compute the indecomposable\nfactors (this can be done by Corollary 4.3  ###reference_###.3  ###reference_i3### and treat them\nindependently. This, of course, could have also been done for the ODD\nconstruction. The key point now is how we treat the indecomposable\nfactors: every selection matrix  for a (blockwise decomposable) indecomposable constraint\nnecessarily has two non-empty blocks. But then every row\n must have at least one empty entry\n. This in turn implies\nthat, once we have chosen , we can exclude  as a possible\nvalue for ! As we have chosen  arbitrarily, this also applies to\nany other variable (maybe with a different domain element ). So the set of possible values for every variable\nshrinks by one and since the\ndomain is finite, this cannot happen too\noften. Algorithm 1  ###reference_### formalizes this recursive idea. To\nbound the runtime of this algorithm, we analyze the size of the\nrecursion tree.\nThe algorithm is formalized in Algorithm 1  ###reference_###. It is\nstraightforward to verify that this algorithm computes an FDD that\ndecides . It remains to discuss the size of the\nFDD and the running time. First note that the decomposition into\nindecomposable factors (Line 10  ###reference_10###) can be computed in polynomial time by\nCorollary 4.3  ###reference_###.3  ###reference_i3###. Moreover, (non-)emptiness of the entries of the selection\nmatrices (Line 19  ###reference_19###) can be tested in\npolynomial time by\nCorollary 4.3  ###reference_###.1  ###reference_i1###. Hence, every call has only polynomial computation\noverhead and we proceed to bound the total number of recursive calls.\nTo this end, let us bound the size of the recursion tree, starting by bounding its depth.\nAs discussed above, the crucial point is that each considered\nselection matrix  in Line 19  ###reference_19###\nhas at least two blocks, otherwise, the relation would have been\ndecomposable, because by definition of blockwise decomposability every block of  is decomposable. Therefore, the test for empty entries will succeed at\nleast once and each considered variable domain shrinks. Therefore, in every root-leaf-path in the recursion tree, there are at most  recursive in Line 22  ###reference_22###. Moreover, on such a path there cannot be two consecutive calls from Line 12  ###reference_12###, because we decompose into indecomposable factors before any such call. It follows that the recursion tree has depth at most .\nLet the height  of a node  in the recursion tree be the distance to the furthest leaf in the subtree below . Let  be the number of variables of the constraint in that call. We claim that the number of leaves below  is at most . We show this by induction on . If , then  is a leaf, so we make no further recursive calls. This only happens if  and the claim is true. Now consider . Let  be the children of . If in  we make a recursive call as in Line 12  ###reference_12###, then . Also for all  we have  and the number of leaves below  is bounded by . If in  we make a recursive call in Line 22  ###reference_22###, then we know that , because we make at most  calls. Moreover, we have again that , so the number of leaves below  is bounded by  which completes the induction and thus proves the claim.\nIt follows that the recursion tree of the algorithm has at most  leaves and thus at most  nodes. Since we add at most one FDD-node per recursive call, this is also a bound for the size of the computed FDD.\n\u220e"
        },
        {
            "section_id": "6",
            "parent_section_id": null,
            "section_name": "Lower Bounds",
            "text": "In this section, we will prove the lower bounds of Theorem 3  ###reference_### and Theorem 3  ###reference_###. In the proofs, we will use the approach developed in [BovaCMS16] that makes a connection between DNNF size and rectangle covers. We will use the following variant:\nLet  be a DNNF of size  representing a constraint  and let . Then, for every , there is a --balanced rectangle cover of  of size . Moreover, if  is structured, then the rectangles in the cover are all with respect to the same variable partition.\n\nThe proof of Lemma 6  ###reference_### is very similar to\nexisting proofs in [BovaCMS16], so we defer it to the appendix.\n{toappendix}"
        },
        {
            "section_id": "6.1",
            "parent_section_id": "6",
            "section_name": "Proof of Lemma 6",
            "text": "In the proof of Lemma 6  ###reference_###, we will again use the concept of proof trees, see Section 2  ###reference_###.\nThe idea of the proof of Lemma 6  ###reference_### is to partition  in the representation (1  ###reference_###), guided by the circuit . To this end, we introduce some more notation. Let, for every gate ,  denote the set of proof trees of  that contain . Moreover, let  denote the variables appearing in  and  the variables that appear in  below the gate . Finally, let .\nis a rectangle w.r.t. .\nEvery proof tree in  can be partitioned into a part below  and the rest. Moreover, any such proof trees  can be combined by combining the part below  from  and the rest from . The claim follows directly from this observation.\n\u220e\nWith Claim 6.1  ###reference_###, we only have to choose the right gates of  to partition  to prove Lemma 6  ###reference_###. To this end, we construct an initially empty rectangle cover  iteratively: while  still captures an assignment , choose a proof tree  capturing  (which is guaranteed to exist by (1  ###reference_###)). By descending in , choose a gate  such that  a fraction of the variables in  between  and 222There is a small edge case here in which  does not contain a third of the variables in . In that case, we simply take  as a rectangle, balancing it by adding the non-appearing variables appropriately.. Add  to , delete  from  and repeat the process. When the iteration stops, we have by Claim 6.1  ###reference_### and the choice of  constructed a set  of -balanced rectangle covers. Moreover,  by construction. Finally, since in the end  does not capture any assignments anymore, every assignment  initially captured must have been computed by one of the proof trees of  that got destroyed by deleting one of its gates . Thus  and we have\nwhich shows the claim of Lemma 6  ###reference_### for the unstructured case.\nIf  is structured, we choose the vertices  in the iteration slightly differently. Let  be the v-tree of . Then we can choose a vertex  in  that has between one and two thirds of the vertices in  as labels on leaves below . Let  be the variable in  below  and let  be the rest of the variables. Now in the construction of , in the proof tree  we can find a gate  below which there are only variables in  and which is closest to the root with this property. Then, by Claim 6.1  ###reference_###,  is a rectangle w.r.t.  and thus in particular -balanced. Since all rectangles we choose this way are with respect to the same partition  which depends only on , the rest of the proof follows as for the unstructured case."
        },
        {
            "section_id": "6.2",
            "parent_section_id": "6",
            "section_name": "Lower Bound for DNNF",
            "text": "In this Section, we show the lower bound for Theorem 3  ###reference_### which we reformulate here.\nLet  be a constraint language that is not strongly blockwise decomposable. Then there is a family of -formulas  of size  and\n such that any DNNF for  has\nsize at least .\nIn the remainder of this section, we show Proposition 6.2  ###reference_###, splitting the proof into two cases.\nFirst, we consider the case where  is not a proper block matrix.\nLet  be a constraint such that  is not a proper block matrix. Then\nthere is a family of -formulas  and\n such that any DNNF for  has size at least .\nIn the proof of Lemma 6.2  ###reference_###, we will use a specific family of graphs. We remind the reader that a matching is a set of edges in a graph that do not share any end-points. The matching is called induced if the graph induced by the end-points of the matching contains exactly the edges of the matching.\n{lemma}\nThere is an integer  and constants ,  such that there is an infinite family \nof bipartite graphs with maximum degree at most  such that for each set  with  there is an induced matching of size at least  in which each edge has exactly one endpoint in .\n\nThe proof of Lemma 6.2  ###reference_### uses a specific class of so-called expander graphs. Since the arguments are rather standard for the area, we defer the proof to Appendix 6.3  ###reference_###.\n{toappendix}"
        },
        {
            "section_id": "6.3",
            "parent_section_id": "6",
            "section_name": "Bipartite graphs with large induced matchings over every cut",
            "text": "In this appendix, we will show how to prove Lemma 6.2  ###reference_###. The construction is based on expander graphs in a rather standard way, but since we have not found an explicit reference, we give it here for completeness.\nWe will use the following construction.\nThere are constants , ,\n such that there is a class of bipartite graphs\n of degree at most  and with  such that for every set  or  with  we have .\nThe proof is an adaption of [MotwaniR95, Theorem 5.6] to our slightly different setting, using the probabilistic method. We will choose the constants  later to make the calculations work, so we let them be variable for now. We fix  and construct  as follows: Set  and . Then choose  permutations  of  and set . Then  is by construction bipartite and has maximum degree of  as required, and it remains only to show the condition on the neighborhoods.\nLet  be the random event that there is a set\n of size  with at most \nneighbors. There are  possible choices of\nsuch a set . Also, for every  there are  sets  in which the neighbors of  can be in\ncase  is true for . Since the probability of\n only depends on the size of  but not\non  itself, we get\nWe have that  if and only if the  permutations  all map  into . So let us first bound the number of permutations which map  into : we first choose the elements into which  is mapped; there are . Then we map the rest of  arbitrarily; there are  ways of doing this. So the overall number of such permutations is . Since the permutations  are chosen independently, we get\nPlugging this in and then using , we get\nWe now set our constants to , , and  and get\nNow let  be the event that there is a subset  of  of size at most  that has at most  neighbors. We get\nThe same analysis for subsets of  yields that the probability that there is a set  in  or  of size at most  that has too few neighbors is at most . It follows that there is a graph  with the desired properties.\n\u220e\nWe call a graph  an  vertex expander\nif , the maximum degree is at most , and for all sets  of at most  vertices, the neighborhood  has size at least .\nThere are constants , ,  such that there is a class of bipartite -expander with  vertices in every color class for infinitely many values .\nWe take the graphs  from Lemma 6.3  ###reference_### with the same values ,  and . Fix  and consider any set  of size at most . Assume w.l.o.g. that , so . Then we get that\n\u220e\nThe class of graphs in Corollary 6.3  ###reference_### will be the class of graphs for Lemma 6.2  ###reference_###. We now construct the distant matchings. To this end, consider a graph  from this class and a set  of vertices of size at most . First construct a matching between  and . Since  has  neighbors outside of  and every vertex had degree at most , one can greedily find such a matching of size . In a second step, we choose an induced matching out of this matching greedily. Since every edge has at most  edges at distance , this yields an induced matching of size  which completes the proof.\nIf  is not a proper block matrix, then, by Lemma 3  ###reference_###, the matrix  has a -submatrix\nwith exactly three non-empty entries. So let  such that  and\n,  and  are all non-empty.\nWe describe a construction that to every bipartite graph  gives a formula  as follows: for every vertex , we introduce a variable  and for every vertex  we introduce a variable . Then, for every edge  where  and , we add a constraint  where  consists of variables only used in this constraint. We fix the notation ,  and .\nLet  be the family of formulas defined by  where  is the family from Lemma 6.2  ###reference_###. Clearly, , as required. Fix  for the remainder of the proof and let . Let \nbe the formula we get from  by restricting all variables  to  and all variables  to  by adding some unary constraints.\nLet  be an --balanced rectangle cover of  where  is the constant from Lemma 6.2  ###reference_###. We claim that the size of  is at least , where\nand  is the degree of .\nTo prove this, we first show that for every ,\n\nSo let . Since  is an --balanced rectangle, we may assume . By choice of , we have that there is an induced matching  in  of size at least  consisting of edges that have\none endpoint corresponding to a variable in  and one endpoint corresponding to a variable in . Consider an edge . Assume that  and . Since we have , we get\nBy construction , so it follows that either  or . Assume w.l.o.g. that  (the other case can be treated analogously). It follows that for each solution , we get a solution  by setting\n,\nFor all , we set ,\nFor all  and all  we set  where  is such that\n.\nNote that values  exist because  is non-empty. Observe that\nfor two different solutions  and  the solutions \nand  may be the same. However, we can bound the number ,\ngiving a lower bound on the set of solutions not in .\nTo this end, suppose that . Since  only changes the values\nof , exactly  -variables and at most  vectors of -variables (the two latter bounds come from the degree bounds on ),\n implies that  and  coincide\non all other variables. This implies\nbecause there are only that many possibilities for the variables that\n might change. By considering , we have shown that\nSo we have constructed \nsolutions not in . Now we consider not only one\nedge but all possible subsets  of edges in :\nfor a solution , the assignment  is constructed as the \nabove, but for all edges . Reasoning as above, we get\nIt is immediate to see that \nfor . Thus we get\nIt follows that every -balanced rectangle cover of  has to have a size of at least .\nWith Lemma 6  ###reference_### and Lemma 2  ###reference_.SSS0.P0.SPx6### it follows that any DNNF for  has to have a size of at least .\n\u220e\nNow we consider the case that  is a proper block matrix, but  is not blockwise decomposable in some pair of variables .\nLet  be a relation such that  is a proper block matrix but  in not blockwise decomposable in  and . Then there is a family of formulas  and\n such that a DNNF for  needs to have a\nsize of at least .\nThe proof follows the same ideas as that of Lemma 6.2  ###reference_###, so we state only the differences. If  is a\nproper block matrix but  is not blockwise decomposable in  and , there is a block  such that  is not decomposable, in such a way that  and  appear in different factors. This implies that if ,  and , then .\nFor one\nmatching edge \nthe projection onto  is\nof the form , so there must exist  and not in .\nThis  is used for the edge  to construct solutions in . Since  is a block, we define  as follows:\n,\nFor all  we set  such that .\nFor all  we set\n such that\n.\nTo bound , note that we have at most \npossibilities in case (a) and, since , at most  possibilities in case (b)\nand (c), respectively.\nIt follows that we can bound the number  for a solution  by\nso we get:\nThe rest of the proof is unchanged.\n\u220e\nWe now have everything in place to prove Proposition 6.2  ###reference_###.\nSince  is not strongly blockwise decomposable, there is a relation  that is not blockwise decomposable in  and . Then, by definition of co-clones and Lemma 4.1  ###reference_###, there is a -formula that defines .\nIf there are variables  such that  is not a proper block matrix, then we can apply Lemma 6.2  ###reference_### to get -formulas that require exponential size DNNF. Then by substituting all occurrences of  in these formula by the -formula defining , we get the required hard -formulas. If all  are proper block matrices, then there are variables  such that  is not blockwise decomposable. Using Lemma 6.3  ###reference_### and reasoning as before, then completes the proof.\n\u220e"
        },
        {
            "section_id": "6.4",
            "parent_section_id": "6",
            "section_name": "Lower Bound for structured DNNF",
            "text": "In this section, we prove the lower bound of Theorem 3  ###reference_### which we formulate here again.\nLet  be a constraint language that is not strongly uniformly blockwise decomposable. Then there is a family of -formulas  of size  and\n such that any structured DNNF for  has\nsize at least .\nNote that for all constraint languages that are not strongly blockwise decomposable, the result follows directly from Proposition 6.2  ###reference_###, so we only have to consider constraint languages which are strongly blockwise decomposable but not strongly uniformly blockwise decomposable. We start with a simple observation.\nLet  be a rectangle with respect to the partition . Let , then  is a rectangle with respect to the partition .\nWe start our proof of Proposition 6.4  ###reference_### by considering a special case.\nLet  be a constraint such that there are two assignments  such that for every partition  of  we have that  or . Consider\nwhere the  are disjoint variable vectors.\nLet  be a variable partition of the variables of  and  be a rectangle cover of  such that each rectangle  in  respects the partition . If for all  we have that all  and  or  and , then  has size at least .\nWe use the so-called fooling set method from communication complexity, see e.g. [KushilevitzN97, Section 1.3]. To this end, we will construct a set  of satisfying assignments of  such that every rectangle of  can contain at most one assignment in .\nSo let  be the assignment to  that assigns the variables analogously to , so , , and . Define analogously . Then the set  consists of all assignments that we get by choosing for every  an assignment  as either  or  and then combining the  to one assignment to all variables of . Note that  contains  assignments and that all of them satisfy , so all of them must be in a rectangle of .\nWe claim that none of the rectangles  of  can contain more than one element . By way of contradiction, assume this were not true. Then there is an  that contains two assignments , so there is an  such that in the construction of  we have chosen  while in the construction of  we have chosen . Let  and . Since , we have that . Moreover, by Observation 6.4  ###reference_###,  is a rectangle and so we have that  and . But  consists only of solutions of  and thus , so . It follows by construction that there is a partition  of  such that  and  are in . This contradicts the assumption on  and  and thus  can only contain one assignment from .\nSince  has size  and all of assignments in  must be in one rectangle of , it follows that  consists of at least  rectangles.\n\u220e\nWe now prove the lower bound of Proposition 6.4  ###reference_###.\nSince  is not strongly uniformly blockwise decomposable, let  be a constraint in  that is not uniformly blockwise decomposable in  and .\nIf  is such that  is not a proper block matrix, then the lemma follows directly from Lemma 6.2  ###reference_###, so we assume in the remainder that  is a proper block matrix. We denote for every block  of  by  the sub-constraint of  we get by restricting  to  and  to . Since  is not uniformly blockwise decomposable, for every partition  of  there is a block  such that .\nGiven a bipartite graph , we construct the same formula  as in the proof of Lemma 6.2  ###reference_###. Consider again the graphs  of the family from Lemma 6.2  ###reference_### and let . Fix  in the remainder of the proof. Let  be a structured DNNF representing  of size . Then, by Proposition 6  ###reference_###, there is an -balanced partition  of  such that there is a rectangle cover of  of size at most  and such that all rectangles respect the partition . Let  be the set of edges  such that  and  are in different parts of the partition . By the properties of , there is an induced matching  of size  consisting of edges in .\nFor every edge  let  and . Assume that  and  (the other case is treated analogously). Then we know that there is a block  of  such that\nSince there are only at most  blocks in , there is a block  such that for at least  edges Equation (15  ###reference_###) is true. Call this set of edges .\nLet . We construct a structured DNNF  from  by existentially quantifying all variables not in a constraint  for  and for all  restricting the domain to   and to  if . Note that every assignment to  that assigns every variable  with  to a value in  and every  with  to a value in  can be extended to a satisfying assignment of , because  is a block. Thus,  is a representation of\nWe now use the following simple observation.\nLet  be a constraint such that . Then there are assignments  such that  or .\nSince  and thus , we have that there is  and  such that . Simply extending  and  to an assignment in  yields the claim.\n\u220e\nSince Claim 6.4  ###reference_### applies to all constraints in , we are now in a situation where we can use Lemma 6.4  ###reference_### which shows that any rectangle cover respecting the partition  for  has size . With Lemma 6  ###reference_###, we know that  and since the construction of  from  does not increase the size of the DNNF, we get .\n\u220e"
        },
        {
            "section_id": "7",
            "parent_section_id": null,
            "section_name": "The Boolean Case",
            "text": "In this section, we will specialize our dichotomy results for the Boolean domain .\nA relation  over  is called bijunctive affine if it can be written as a conjunction of the relations  and  and unary relations, so  with  where  and }. A set of relations  is called bijunctive affine if all  are bijunctive affine. We will show the following dichotomy for the Boolean case:\nLet  be a constraint language over the Boolean domain. If all relations in  are bijunctive affine, then there is an polynomial time algorithm that, given\na -formula , constructs an OBDD for . If not, then\nthere is a family of -formulas  and  such that a DNNF\nfor  needs to have a size of at least .\n\nLet us remark here that, in contrast to general domains , there is no advantage of FDD over ODD in the Boolean case: either a constraint language allows for efficient representation by ODD or it is hard even for DNNF. So in a sense, the situation over the Boolean domain is easier. Also note that the tractable cases over the Boolean domain are very restricted, allowing only equalities and disequalities.\nWith Theorem 3  ###reference_### and Theorem 3  ###reference_###, we only need to show the following:\nEvery  is strongly uniformly blockwise decomposable.\nIf  is strongly blockwise decomposable, then .\nWe show that  is strongly uniformly blockwise decomposable \u2013 which implies that every  is also strongly uniformly blockwise decomposable. Let . Then  can be constructed by conjunctions of constraints in the relations of  and projections. Let  be the relation we get by the same conjunctions as for  but not doing any of the projections. By Lemma 4.1  ###reference_###, it suffices to show that  is uniformly blockwise decomposable. To this end, consider the graph  with , two vertices  and  are connected with a blue edge if the representation of  contains  and connected with a red edge if  contains . A vertex  is blue if  contains  and red if  contains .\nIf  is represented by\nthen  is the graph in Figure 3  ###reference_###.\n\u220e\nWe show that  is a proper block matrix and each block is decomposable using the same variable partition. If  and  are in different connected components of ,  is decomposable such that  and  appear in different factors, so  has only one block which is decomposable. If  has no satisfying assignments, there is nothing to show. It remains the case where  has satisfying assignments and  and  are in the same connected component.\nSo let  have at least one model and let  have only one connected component. Note that setting one variable in  to  or  determines the value of all other variables in . This implies that if a vertex in  is colored, then  has three empty entries and one entry with exactly one element. If no vertex in  is colored, then  is either  (if every path from  to  has an even number of red edges) or  (if every path from  to  has an odd number of edges). So  has exactly two non-empty entries with one element each, so  is decomposable in  and . This completes the proof of Item 1  ###reference_i1###.\nLet now  be strongly blockwise decomposable and  be decomposed into indecomposable factors\nWe have to show that  for all  which implies that ). Since  is indecomposable,  has to have at least two blocks for every . Since  is Boolean, only two cases remain:  is either equality or disequality on  and . In every case, the value of  determines the value of  and vice versa. Since  and  are arbitrary, each variable in  determines the value of every other variable in . This implies that non-empty entries of  have exactly one element. It follows that  has exactly two satisfying assignments and moreover, no variable can take the same value in these two assignments since otherwise  would be decomposable. It follows that after fixing a value for a variable , the values of all other variables  are determined by the constraint  or , so  is a conjunction of constraints with relations in  which completes the proof of Item 2  ###reference_i2### and thus the theorem.\n\u220e"
        },
        {
            "section_id": "8",
            "parent_section_id": null,
            "section_name": "Decidability of Strong (Uniform) Blockwise Decomposability",
            "text": "In this section, we will show that strong (uniform) blockwise decomposability is decidable."
        },
        {
            "section_id": "8.1",
            "parent_section_id": "8",
            "section_name": "The Algorithm",
            "text": "We will here first give the algorithm to decide strong (uniform) blockwise decomposability. The algorithm will rely on properties of constraint languages formulated below in Proposition 8.1  ###reference_### which we will then prove in the following sections.\nFor our algorithm, we will heavily rely on the following well-known result for deciding containment in co-clones whose proof can be found in [Dalmau00, Lemma 42].\nThere is an algorithm that, given a constraint language  and a relation , decides if .\nIn a first step in our algorithm, we would like to restrict to the\ncase of binary relations by taking binary projections as it is done in\nProposition 4.1  ###reference_###. However, as the following example shows, this is in general not correct since there are constraint languages that are not blockwise decomposable while their binary projection is.\nConsider the relation  which is the parity relation on three variables. Consider the constraint  and the selection matrix\nThe single block of this matrix is obviously not decomposable, so  is not blockwise decomposable.\nLet us now compute . To this end, call a relation affine if it is the solution set of a system of linear equations over the finite field  with  elements. Obviously, all -formulas define affine relations. The following fact is well known, see e.g. [Dalmau00, Lemma 5] for a proof.\nEvery projection of an affine constraint is affine.\nIt follows that  only contains affine relations of arity at most . But, as we saw in the proof of Theorem 7  ###reference_###, in that case  is strongly uniformly blockwise decomposable.\nAs a consequence, we have that  is not blockwise decomposable while its binary projection is even strongly uniformly blockwise decomposable.\n\u220e\nTo avoid the problem of Example 8.1  ###reference_###, we will make\nsure that for the constraint language at hand we have\n, which we will test with the help of\nTheorem 8.1  ###reference_### below. If this is\nnot the case, then by the contraposition of\nProposition 4.1  ###reference_###, we already know that the\nlanguage  is not strongly blockwise decomposable.\nAfterwards, we can focus on  and utilize the following\nproposition, which is the main technical contribution of this section.\nLet  be a constraint language and\n the constraint language consisting of all unary and binary pp-definable relations over .\nis strongly uniformly blockwise decomposable if and\nonly if all relations of arity at most  in\n are uniformly blockwise decomposable.\nis strongly blockwise decomposable if and only if all relations of arity at most  in  are blockwise decomposable.\nBefore we prove Proposition 8.1  ###reference_### in the next two subsections, let us show how it yields the desired decidability results.\nThere is an algorithm that, given a constraint language , decides if  is strongly blockwise decomposable. Moreover, there is also an algorithm that, given a constraint language , decides if  is strongly uniformly blockwise decomposable.\nWe only consider blockwise decomposability since the proof for uniform decomposability is completely analogous.\nLet  be the given constraint language over the domain .\nCompute  by testing for every\nunary and binary relation  over  whether\n using\nTheorem 8.1  ###reference_###.\nAgain using Theorem 8.1  ###reference_###,\nwe test for every , whether\n. If the answer is no, then by\nwe can conclude by Proposition 4.1  ###reference_### that\n is not strongly blockwise decomposable. Otherwise, we know that .\nBy applying Theorem 8.1  ###reference_### a\nthird time, we compute all at most ternary relations in\n and test whether they are blockwise\ndecomposable by a brute-force application of Definition 3  ###reference_###. By\nProposition 8.1  ###reference_### this is the case if and only if\n and hence  is strongly blockwise\ndecomposable. \u220e"
        },
        {
            "section_id": "8.2",
            "parent_section_id": "8",
            "section_name": "Proof of Proposition 8.1.1 (the uniform case)",
            "text": "In this section, we will show Proposition 8.1  ###reference_### for the\ncase of strong uniform blockwise decomposability. Obviously, if\n contains a relation of arity at most  that is\nnot uniformly blockwise decomposable, then  is not strongly\nuniformly blockwise decomposable. So we only have to show the other\ndirection of the claim.\nWe first aim to get a better understanding of . Let . By Lemma 4.1  ###reference_###, it suffices to consider the case in which  has a pp-definition without any projections, so there is a pp-definition of the constraint  of the form\nwhere  is a relation from  (here we use that\n as it is pp-definable and that \nis closed under intersections).\nWe show that in our setting we get a decomposition as in Lemma 5.1  ###reference_###.\nFor any  there is an undirected tree\n with vertex set  and edge  such that\nIf  has less than three variables, there is nothing to show, so\nwe will first consider the case of , showing first the\nfollowing slightly stronger statement ():\nLet  be a ternary\nconstraint with constraint relation in , then in the representation (16  ###reference_###) one of the constraints  or  is the trivial constraint .\nSince we are proving the backward direction of Proposition 8.1  ###reference_###.1,  is\nuniformly blockwise decomposable by assumption. Thus, we can apply\nLemma 4.3  ###reference_### to see that  can be rewritten in one of the forms\nAssertion () immediately follows and\nsetting  and  proves Claim 8.2  ###reference_###\nfor .\nNow assume that . Choose any variable  and consider the formula\nThen we have by definition that\nWe claim that we can rewrite  such that only at most one of the  is not the trivial relation . To see this, assume that there are two different variables  such that  and  are both nontrivial. Let  be the constraint defined by  and let . Consider the formula . Applying (), we get that we can rewrite  such that one of  or  is trivial. Substituting this rewrite in for  in  and iterating the process yields that there is in the end only one non-trivial . Let  be the only variable for which  might be non-trivial, then we can assume that\nSince  has fewer variables than , we get by induction that\nthere is a tree  with vertex set  and\n such that\nAdding  as a new leaf connected to  gives the desired tree for .\n\u220e\nUsing Claim 8.2  ###reference_###, we now show that  is\nuniformly blockwise decomposable. To this end, we fix two variables\n and show that  is uniformly blockwise decomposable in .\nTo see that  is a proper block matrix, observe that  has the same non-empty entries as . But  is in  and thus by assumption uniformly blockwise decomposable. It follows that its selection matrix is a proper block matrix which is then also true for .\nWe now apply Claim 8.2  ###reference_### to  and let  be the\nresulting tree. Since  is an edge in ,\n consists of two trees  and ,\ncontaining  and , respectively. By setting\n and ,\nClaim 8.2  ###reference_### implies that  can be written as\nThis implies that each block of  is decomposable in\n and hence that  is uniformly blockwise\ndecomposable."
        },
        {
            "section_id": "8.3",
            "parent_section_id": "8",
            "section_name": "Proof of Proposition 8.1.2 (the nonuniform case)",
            "text": "In this section, we prove Proposition 8.1  ###reference_### for the case\nof blockwise decomposability, so let  be a\nconstraint language and . We will first define the following new property of .\nWe say that  has an incompatible block structure if and only if there are binary relations  in  such that  has blocks  and  and  has blocks  and  such that , , , and  are all non-empty.\nIn the remainder of this section we will show that the following are\nequivalent, the equivalence between (1) and (2) then establishes Proposition 8.1  ###reference_###.2:\nis strongly blockwise decomposable.\nEvery ternary relation in  is blockwise decomposable.\nis blockwise decomposable and has no incompatible block structure.\nThe direction (1)  (2) is trivial, (2)  (3)\nwill be shown in Lemma 8.3  ###reference_###, and (3)  (1) is stated in Lemma 8.3  ###reference_###.\nIf  has an incompatible block structure, then  contains a ternary relation that is not blockwise decomposable.\nLet  and the corresponding blocks be chosen as in Definition 8.3  ###reference_###. We claim that the constraint\nis not blockwise decomposable. To this end, choose values . Then we have by construction that\nand all these sets are all non-empty because of the incompatible block structure. Now assume, by way of contradiction, that  is blockwise decomposable. Then  is a proper block matrix and the entries  all lie in the same block . Then  decoposes with respect to , because we assumed that  is blockwise decomposable, so\nHowever, in the first case we have\nso in particular there is an element of  in both  and  which contradicts the assumption that  and  are different blocks of .\nIn the second case, we get\nwhich leads to an analogous contradiction to  and  being blocks of . Thus, in both cases we get a contradiction, so  cannot be blockwise decomposable.\n\u220e\nIf  is blockwise decomposable and has no incompatible block structure, then it is strongly blockwise decomposable.\nLet  be in . We will show that \nis blockwise decomposable. Because of\nLemma 4.1  ###reference_###, we may w.l.o.g. assume\nthat  is pp-definable by a -formula without\nprojection. Thus, as in the proof of Proposition 8.1  ###reference_###.1 we can write  as\nwhere . Now using again the fact that\n and thus in particular  for all , we can actually write  as\nFix two variables . Since  is blockwise decomposable\nby assumption of the lemma, we have that  and hence  is a proper block matrix (because\nthey have the same block structure). We have to show that all of its blocks decompose. So fix a block  of  and consider the restriction . As before, we get a representation\nWe now assign a graph  to  as follows: vertices are the\nvariables in ; two variables  are connected by an edge\nif and only if  has more than one block. Since \nis blockwise decomposable, we have, again using that , that all  are proper\nblock matrices. So the variables  that are not connected are\nexactly those where  has exactly one block. So in\nparticular, there is no edge between  and . The crucial\nproperty is that the edge relation is transitive:\nFor all , if  and  are edges in , then  is also an edge.\nAgain, for all , the matrices  and  have the same blocks. Thus,  is an edge in  if and only if  has more than one block.\nWe will use the following observation throughout the remainder of this proof which follows directly from the fact that we have .\nFor every element  there must be a block  of  and a block  of  that both contain .\nLet  be the blocks of\n and  be the blocks of\n. By assumption of the claim we have  and\nby Observation 8.3  ###reference_### . We claim that then there are two blocks\n and  such that for all  we have . To see this, consider two cases: if there is an  that is not fully contained in any , then we can choose an arbitrary other set  to satisfy the claim. Otherwise, choose  arbitrarily such that . Since , there are elements from  that are not in  and thus there is an . But then  has the desired property since  contains only elements from . So in any case we can choose  such that for all  we have that .\nIt follows that we can fix two distinct\nblocks  and  such that  and . Since\n does not have an incompatible block structure, it must be\nthe case that either  or . W.l.o.g. assume\nthe former. It follows that for any ,  and\nevery domain element  it is not the case that  and . Therefore  and . Since by\nthe choice of  and  we have  and , we get that  has\nnon-empty entries in row  and column  but not at their intersection, implying that the matrix contains at least\ntwo blocks. This finishes the proof of Claim 8.3  ###reference_###.\n\u220e\nIt remains to prove that  is decomposable w.r.t. some partition \nwith  and . To this end, we let  be the connected\ncomponent of  in the graph  and . Note\nthat  because  is not an edge and the edge relation is\ntransitive. For every  and  the matrix\n has exactly one block and therefore\n. This\nimplies that\nproving that  is decomposable w.r.t. .\n\u220e"
        },
        {
            "section_id": "8.4",
            "parent_section_id": "8",
            "section_name": "A separating example",
            "text": "We have established that strong blockwise decomposability as well\nas strong uniform blockwise decomposability are decidable. It follows\nthat there is an algorithm that decides for a given constraint language \nif either\nevery CSP() instance can be encoded into a polynomial-size ODD or\nevery CSP() instance can be encoded into a polynomial-size FDD,\nbut some\nCSP() instances require exponential-size ODDs (and structured\nDNNFs) or\nthere are CSP() instances that require exponential-size FDDs\n(and DNNFs).\nWe have seen that there are constraint languages falling in the first\nand third category. Furthermore, there is no Boolean constraint\nlanguage falling in the second category. However, in\nthe non-Boolean case there are constraint languages with this property.\nTo see this, we utilize our new criterion for strong blockwise\ndecomposability: A constraint language is strongly blockwise\ndecomposable if and only if every binary relation in  is\nblockwise decomposable (which is the same as being rectangular [DyerR13]) and there are no two relations in \nwith an incompatible block structure. Lets come back to our running\nexample  from Section 4.1  ###reference_###, see\nFigure 1  ###reference_###. We have already observed in Example 3  ###reference_### that\n is not uniformly blockwise decomposable and hence  is not\nstrongly uniformly blockwise decomposable. Moreover, we have computed  in\nExample 4.1  ###reference_###. By inspecting these relations (see Figure 4  ###reference_###) it follows that they are\nall blockwise decomposable and that no two relations have pairs of incompatible\nblocks as stated in Definition 8.3  ###reference_###. It\nfollows by Lemma 8.3  ###reference_### that  is strongly\nblockwise decomposable and thus  serves as a separating example\nof our two central notions. This leads to the following theorem, which\nshould be contrasted with the Boolean case where both notions collapse\n(Theorem 7  ###reference_###).\nThere is a constraint language  over a 4-element domain that is strongly\nblockwise decomposable, but not strongly uniformly\nblockwise decomposable. Thus, every CSP() instance can be\ndecided by a polynomial-size FDD, but there are CSP()\ninstances that require structured DNNFs (and ODDs) of exponential size."
        },
        {
            "section_id": "9",
            "parent_section_id": null,
            "section_name": "Conclusion",
            "text": "We have seen that there is a dichotomy for compiling systems of constraints into DNNF based on the constraint languages. It turns out that the constraint languages that allow efficient compilation are rather restrictive, in the Boolean setting they consist essentially only of equality and disequality. From a practical perspective, our results are thus largely negative since interesting settings will most likely lie outside the tractable cases we have identified.\nWithin the polynomially compilable constraint languages we have identified and\nseparated two categories, depending on whether they guarantee polynomial-size\nstructured representations. Moreover, both properties are decidable.\nA few questions remain open. The first is to get a better grasp on the\nefficiently compilable constraint languages. Is there is simpler\ncombinatorial description, or is there an algebraic characterization\nusing polymorphisms? Is there a simpler way of testing strong\n(uniform) blockwise decomposability that avoids\nTheorem 8.1  ###reference_###? What is the exact\ncomplexity?"
        }
    ],
    "appendix": [],
    "tables": {},
    "image_paths": {},
    "validation": true,
    "references": [
        {
            "1": {
                "title": "Unbalancing sets and an almost quadratic lower bound for\nsyntactically multilinear arithmetic circuits.",
                "author": "Noga Alon, Mrinal Kumar, and Ben Lee Volk.",
                "venue": "Comb., 40(2):149\u2013178, 2020.",
                "url": null
            }
        },
        {
            "2": {
                "title": "A circuit-based approach to efficient enumeration.",
                "author": "Antoine Amarilli, Pierre Bourhis, Louis Jachiet, and Stefan Mengel.",
                "venue": "In Ioannis Chatzigiannakis, Piotr Indyk, Fabian Kuhn, and Anca\nMuscholl, editors, 44th International Colloquium on Automata, Languages,\nand Programming, ICALP 2017, July 10-14, 2017, Warsaw, Poland, volume 80\nof LIPIcs, pages 111:1\u2013111:15. Schloss Dagstuhl - Leibniz-Zentrum\nf\u00fcr Informatik, 2017.",
                "url": null
            }
        },
        {
            "3": {
                "title": "Connecting knowledge compilation classes and width parameters.",
                "author": "Antoine Amarilli, Florent Capelli, Mika\u00ebl Monet, and Pierre Senellart.",
                "venue": "Theory Comput. Syst., 64(5):861\u2013914, 2020.",
                "url": null
            }
        },
        {
            "4": {
                "title": "Compiling CSPs: A complexity map of (non-deterministic)\nmultivalued decision diagrams.",
                "author": "J\u00e9r\u00f4me Amilhastre, H\u00e9l\u00e8ne Fargier, Alexandre Niveau,\nand C\u00e9dric Pralet.",
                "venue": "Int. J. Artif. Intell. Tools, 23(4), 2014.",
                "url": null
            }
        },
        {
            "5": {
                "title": "A characterization of efficiently compilable constraint languages.",
                "author": "Christoph Berkholz, Stefan Mengel, and Hermann Wilhelm.",
                "venue": "In Olaf Beyersdorff, Mamadou Moustapha Kant\u00e9, Orna Kupferman,\nand Daniel Lokshtanov, editors, 41st International Symposium on\nTheoretical Aspects of Computer Science, STACS 2024, March 12-14, 2024,\nClermont-Ferrand, France, volume 289 of LIPIcs, pages 11:1\u201311:19.\nSchloss Dagstuhl - Leibniz-Zentrum f\u00fcr Informatik, 2024.",
                "url": null
            }
        },
        {
            "6": {
                "title": "A dichotomy for succinct representations of homomorphisms.",
                "author": "Christoph Berkholz and Harry Vinall-Smeeth.",
                "venue": "In Kousha Etessami, Uriel Feige, and Gabriele Puppis, editors, 50th International Colloquium on Automata, Languages, and Programming,\nICALP 2023, July 10-14, 2023, Paderborn, Germany, volume 261 of LIPIcs, pages 113:1\u2013113:19. Schloss Dagstuhl - Leibniz-Zentrum f\u00fcr\nInformatik, 2023.",
                "url": null
            }
        },
        {
            "7": {
                "title": "Expander CNFs have exponential DNNF size.",
                "author": "Simone Bova, Florent Capelli, Stefan Mengel, and Friedrich Slivovsky.",
                "venue": "CoRR, abs/1411.1995, 2014.",
                "url": null
            }
        },
        {
            "8": {
                "title": "Knowledge compilation meets communication complexity.",
                "author": "Simone Bova, Florent Capelli, Stefan Mengel, and Friedrich Slivovsky.",
                "venue": "In Subbarao Kambhampati, editor, Proceedings of the Twenty-Fifth\nInternational Joint Conference on Artificial Intelligence, IJCAI 2016, New\nYork, NY, USA, 9-15 July 2016, pages 1008\u20131014. IJCAI/AAAI Press, 2016.",
                "url": null
            }
        },
        {
            "9": {
                "title": "Graph-based algorithms for boolean function manipulation.",
                "author": "Randal E. Bryant.",
                "venue": "IEEE Trans. Computers, 35(8):677\u2013691, 1986.",
                "url": null
            }
        },
        {
            "10": {
                "title": "The complexity of the counting constraint satisfaction problem.",
                "author": "Andrei A. Bulatov.",
                "venue": "J. ACM, 60(5):34:1\u201334:41, 2013.",
                "url": null
            }
        },
        {
            "11": {
                "title": "A dichotomy theorem for nonuniform CSPs.",
                "author": "Andrei A. Bulatov.",
                "venue": "In Chris Umans, editor, 58th IEEE Annual Symposium on\nFoundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October\n15-17, 2017, pages 319\u2013330. IEEE Computer Society, 2017.",
                "url": null
            }
        },
        {
            "12": {
                "title": "Enumerating homomorphisms.",
                "author": "Andrei A. Bulatov, V\u00edctor Dalmau, Martin Grohe, and D\u00e1niel Marx.",
                "venue": "J. Comput. Syst. Sci., 78(2):638\u2013650, 2012.",
                "url": null
            }
        },
        {
            "13": {
                "title": "Complexity of counting CSP with complex weights.",
                "author": "Jin-Yi Cai and Xi Chen.",
                "venue": "J. ACM, 64(3):19:1\u201319:39, 2017.",
                "url": null
            }
        },
        {
            "14": {
                "title": "Understanding the complexity of #SAT using knowledge\ncompilation.",
                "author": "Florent Capelli.",
                "venue": "In 32nd Annual ACM/IEEE Symposium on Logic in Computer\nScience, LICS 2017, Reykjavik, Iceland, June 20-23, 2017, pages 1\u201310.\nIEEE Computer Society, 2017.",
                "url": null
            }
        },
        {
            "15": {
                "title": "Tractable QBF by Knowledge Compilation.",
                "author": "Florent Capelli and Stefan Mengel.",
                "venue": "In Rolf Niedermeier and Christophe Paul, editors, 36th\nInternational Symposium on Theoretical Aspects of Computer Science (STACS\n2019), volume 126 of Leibniz International Proceedings in Informatics\n(LIPIcs), pages 18:1\u201318:16, Dagstuhl, Germany, 2019. Schloss\nDagstuhl\u2013Leibniz-Zentrum fuer Informatik.",
                "url": null
            }
        },
        {
            "16": {
                "title": "The complexity of general-valued constraint satisfaction problems\nseen from the other side.",
                "author": "Cl\u00e9ment Carbonnel, Miguel Romero, and Stanislav Zivn\u00fd.",
                "venue": "SIAM J. Comput., 51(1):19\u201369, 2022.",
                "url": null
            }
        },
        {
            "17": {
                "title": "Dynamic minimization of sentential decision diagrams.",
                "author": "Arthur Choi and Adnan Darwiche.",
                "venue": "In Marie desJardins and Michael L. Littman, editors, Proceedings\nof the Twenty-Seventh AAAI Conference on Artificial Intelligence, July\n14-18, 2013, Bellevue, Washington, USA, pages 187\u2013194. AAAI Press,\n2013.",
                "url": null
            }
        },
        {
            "18": {
                "title": "A dichotomy theorem for maximum generalized satisfiability problems.",
                "author": "Nadia Creignou.",
                "venue": "J. Comput. Syst. Sci., 51(3):511\u2013522, 1995.",
                "url": null
            }
        },
        {
            "19": {
                "title": "Complexity of generalized satisfiability counting problems.",
                "author": "Nadia Creignou and Miki Hermann.",
                "venue": "Inf. Comput., 125(1):1\u201312, 1996.",
                "url": null
            }
        },
        {
            "20": {
                "title": "Complexity classifications of boolean constraint satisfaction\nproblems.",
                "author": "Nadia Creignou, Sanjeev Khanna, and Madhu Sudan.",
                "venue": "SIAM, 2001.",
                "url": null
            }
        },
        {
            "21": {
                "title": "Enumerating all solutions of a boolean CSP by non-decreasing\nweight.",
                "author": "Nadia Creignou, Fr\u00e9d\u00e9ric Olive, and Johannes Schmidt.",
                "venue": "In Karem A. Sakallah and Laurent Simon, editors, Theory and\nApplications of Satisfiability Testing - SAT 2011 - 14th International\nConference, SAT 2011, Ann Arbor, MI, USA, June 19-22, 2011. Proceedings,\nvolume 6695 of Lecture Notes in Computer Science, pages 120\u2013133.\nSpringer, 2011.",
                "url": null
            }
        },
        {
            "22": {
                "title": "Computational Complexity of Problems over Generalized Formulas.",
                "author": "V\u00edctor Dalmau.",
                "venue": "PhD thesis, Universitat Polit\u00e9cnica de Catalunya, 2000.",
                "url": null
            }
        },
        {
            "23": {
                "title": "The complexity of counting homomorphisms seen from the other side.",
                "author": "V\u00edctor Dalmau and Peter Jonsson.",
                "venue": "Theor. Comput. Sci., 329(1-3):315\u2013323, 2004.",
                "url": null
            }
        },
        {
            "24": {
                "title": "Decomposable negation normal form.",
                "author": "Adnan Darwiche.",
                "venue": "J. ACM, 48(4):608\u2013647, 2001.",
                "url": null
            }
        },
        {
            "25": {
                "title": "New advances in compiling CNF into decomposable negation normal\nform.",
                "author": "Adnan Darwiche.",
                "venue": "In Ram\u00f3n L\u00f3pez de M\u00e1ntaras and Lorenza Saitta,\neditors, Proceedings of the 16th Eureopean Conference on Artificial\nIntelligence, ECAI\u20192004, including Prestigious Applicants of Intelligent\nSystems, PAIS 2004, Valencia, Spain, August 22-27, 2004, pages 328\u2013332.\nIOS Press, 2004.",
                "url": null
            }
        },
        {
            "26": {
                "title": "A knowledge compilation map.",
                "author": "Adnan Darwiche and Pierre Marquis.",
                "venue": "J. Artif. Intell. Res., 17:229\u2013264, 2002.",
                "url": null
            }
        },
        {
            "27": {
                "title": "Query processing on probabilistic data: A survey.",
                "author": "Guy Van den Broeck and Dan Suciu.",
                "venue": "Found. Trends Databases, 7(3-4):197\u2013341, 2017.",
                "url": null
            }
        },
        {
            "28": {
                "title": "An effective dichotomy for the counting constraint satisfaction\nproblem.",
                "author": "Martin E. Dyer and David Richerby.",
                "venue": "SIAM J. Comput., 42(3):1245\u20131274, 2013.",
                "url": null
            }
        },
        {
            "29": {
                "title": "On the use of partially ordered decision graphs in knowledge\ncompilation and quantified boolean formulae.",
                "author": "H\u00e9l\u00e8ne Fargier and Pierre Marquis.",
                "venue": "In Proceedings, The Twenty-First National Conference on\nArtificial Intelligence and the Eighteenth Innovative Applications of\nArtificial Intelligence Conference, July 16-20, 2006, Boston, Massachusetts,\nUSA, pages 42\u201347. AAAI Press, 2006.",
                "url": null
            }
        },
        {
            "30": {
                "title": "The complexity of homomorphism and constraint satisfaction problems\nseen from the other side.",
                "author": "Martin Grohe.",
                "venue": "J. ACM, 54(1), mar 2007.",
                "url": null
            }
        },
        {
            "31": {
                "title": "Sur les assemblages de lignes.",
                "author": "Camille Jordan.",
                "venue": "Journal f\u00fcr die reine und angewandte Mathematik,\n70:185\u2013190, 1869.",
                "url": null
            }
        },
        {
            "32": {
                "title": "The approximability of constraint satisfaction problems.",
                "author": "Sanjeev Khanna, Madhu Sudan, Luca Trevisan, and David P. Williamson.",
                "venue": "SIAM J. Comput., 30(6):1863\u20131920, 2000.",
                "url": null
            }
        },
        {
            "33": {
                "title": "Compiling constraint networks into multivalued decomposable decision\ngraphs.",
                "author": "Fr\u00e9d\u00e9ric Koriche, Jean-Marie Lagniez, Pierre Marquis, and Samuel\nThomas.",
                "venue": "In Qiang Yang and Michael Wooldridge, editors, Proceedings of\nthe Twenty-Fourth International Joint Conference on Artificial Intelligence,\nIJCAI 2015, Buenos Aires, Argentina, July 25-31, 2015, pages 332\u2013338.\nAAAI Press, 2015.",
                "url": null
            }
        },
        {
            "34": {
                "title": "Communication complexity.",
                "author": "Eyal Kushilevitz and Noam Nisan.",
                "venue": "Cambridge University Press, 1997.",
                "url": null
            }
        },
        {
            "35": {
                "title": "An improved decision-dnnf compiler.",
                "author": "Jean-Marie Lagniez and Pierre Marquis.",
                "venue": "In Carles Sierra, editor, Proceedings of the Twenty-Sixth\nInternational Joint Conference on Artificial Intelligence, IJCAI 2017,\nMelbourne, Australia, August 19-25, 2017, pages 667\u2013673. ijcai.org, 2017.",
                "url": null
            }
        },
        {
            "36": {
                "title": "Characterizing valiant\u2019s algebraic complexity classes.",
                "author": "Guillaume Malod and Natacha Portier.",
                "venue": "J. Complex., 24(1):16\u201338, 2008.",
                "url": null
            }
        },
        {
            "37": {
                "title": "Compiling constraint networks into AND/OR multi-valued decision\ndiagrams (aomdds).",
                "author": "Robert Mateescu and Rina Dechter.",
                "venue": "In Fr\u00e9d\u00e9ric Benhamou, editor, Principles and\nPractice of Constraint Programming - CP 2006, 12th International\nConference, CP 2006, Nantes, France, September 25-29, 2006, Proceedings,\nvolume 4204 of Lecture Notes in Computer Science, pages 329\u2013343.\nSpringer, 2006.",
                "url": null
            }
        },
        {
            "38": {
                "title": "AND/OR multi-valued decision diagrams (aomdds) for graphical\nmodels.",
                "author": "Robert Mateescu, Rina Dechter, and Radu Marinescu.",
                "venue": "J. Artif. Intell. Res., 33:465\u2013519, 2008.",
                "url": null
            }
        },
        {
            "39": {
                "title": "Randomized Algorithms.",
                "author": "Rajeev Motwani and Prabhakar Raghavan.",
                "venue": "Cambridge University Press, 1995.",
                "url": null
            }
        },
        {
            "40": {
                "title": "Dsharp: Fast d-dnnf compilation with sharpSAT.",
                "author": "Christian J. Muise, Sheila A. McIlraith, J. Christopher Beck, and Eric I. Hsu.",
                "venue": "In Leila Kosseim and Diana Inkpen, editors, Advances in\nArtificial Intelligence - 25th Canadian Conference on Artificial\nIntelligence, Canadian AI 2012, Toronto, ON, Canada, May 28-30, 2012.\nProceedings, volume 7310 of Lecture Notes in Computer Science, pages\n356\u2013361. Springer, 2012.",
                "url": null
            }
        },
        {
            "41": {
                "title": "Factorized databases: A knowledge compilation perspective.",
                "author": "Dan Olteanu.",
                "venue": "In Adnan Darwiche, editor, Beyond NP, Papers from the 2016\nAAAI Workshop, Phoenix, Arizona, USA, February 12, 2016, volume WS-16-05\nof AAAI Technical Report. AAAI Press, 2016.",
                "url": null
            }
        },
        {
            "42": {
                "title": "Size bounds for factorised representations of query results.",
                "author": "Dan Olteanu and Jakub Z\u00e1vodn\u00fd.",
                "venue": "ACM Trans. Database Syst., 40(1):2:1\u20132:44, 2015.",
                "url": null
            }
        },
        {
            "43": {
                "title": "A top-down compiler for sentential decision diagrams.",
                "author": "Umut Oztok and Adnan Darwiche.",
                "venue": "In Qiang Yang and Michael J. Wooldridge, editors, Proceedings of\nthe Twenty-Fourth International Joint Conference on Artificial Intelligence,\nIJCAI 2015, Buenos Aires, Argentina, July 25-31, 2015, pages 3141\u20133148.\nAAAI Press, 2015.",
                "url": null
            }
        },
        {
            "44": {
                "title": "New compilation languages based on structured decomposability.",
                "author": "Knot Pipatsrisawat and Adnan Darwiche.",
                "venue": "In Dieter Fox and Carla P. Gomes, editors, Proceedings of the\nTwenty-Third AAAI Conference on Artificial Intelligence, AAAI 2008,\nChicago, Illinois, USA, July 13-17, 2008, pages 517\u2013522. AAAI Press,\n2008.",
                "url": null
            }
        },
        {
            "45": {
                "title": "A lower bound for the size of syntactically multilinear arithmetic\ncircuits.",
                "author": "Ran Raz, Amir Shpilka, and Amir Yehudayoff.",
                "venue": "SIAM J. Comput., 38(4):1624\u20131647, 2008.",
                "url": null
            }
        },
        {
            "46": {
                "title": "The complexity of satisfiability problems.",
                "author": "Thomas J. Schaefer.",
                "venue": "In Richard J. Lipton, Walter A. Burkhard, Walter J. Savitch, Emily P.\nFriedman, and Alfred V. Aho, editors, Proceedings of the 10th Annual\nACM Symposium on Theory of Computing, May 1-3, 1978, San Diego, California,\nUSA, pages 216\u2013226. ACM, 1978.",
                "url": null
            }
        },
        {
            "47": {
                "title": "The complexity of finite-valued csps.",
                "author": "Johan Thapper and Stanislav Zivn\u00fd.",
                "venue": "J. ACM, 63(4):37:1\u201337:33, 2016.",
                "url": null
            }
        },
        {
            "48": {
                "title": "Properties that characterize LOGCFL.",
                "author": "H. Venkateswaran.",
                "venue": "In Alfred V. Aho, editor, Proceedings of the 19th Annual ACM\nSymposium on Theory of Computing, 1987, New York, New York, USA, pages\n141\u2013150. ACM, 1987.",
                "url": null
            }
        },
        {
            "49": {
                "title": "Branching Programs and Binary Decision Diagrams.",
                "author": "Ingo Wegener.",
                "venue": "SIAM, 2000.",
                "url": null
            }
        },
        {
            "50": {
                "title": "A proof of CSP dichotomy conjecture.",
                "author": "Dmitriy Zhuk.",
                "venue": "In Chris Umans, editor, 58th IEEE Annual Symposium on\nFoundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October\n15-17, 2017, pages 331\u2013342. IEEE Computer Society, 2017.",
                "url": null
            }
        }
    ],
    "url": "http://arxiv.org/html/2311.10040v2"
}