A Join-Based Hybrid Parameter for Constraint Satisfaction

TL;DR

This paper introduces joinwidth, a new hybrid complexity parameter for CSPs that combines structural and relational aspects, enabling polynomial and fixed-parameter algorithms for broader classes of instances.

Contribution

The paper defines joinwidth, demonstrating it generalizes existing parameters like hypertree width and fractional hypertree width, unifying various tractable classes of CSPs.

Findings

Joinwidth captures larger tractable classes than structural parameters.

Bounded joinwidth classes include those with bounded fractional hypertree width.

Joinwidth unifies multiple hybrid restrictions, explaining their tractability.

Abstract

We propose joinwidth, a new complexity parameter for the Constraint Satisfaction Problem (CSP). The definition of joinwidth is based on the arrangement of basic operations on relations (joins, projections, and pruning), which inherently reflects the steps required to solve the instance. We use joinwidth to obtain polynomial-time algorithms (if a corresponding decomposition is provided in the input) as well as fixed-parameter algorithms (if no such decomposition is provided) for solving the CSP. Joinwidth is a hybrid parameter, as it takes both the graphical structure as well as the constraint relations that appear in the instance into account. It has, therefore, the potential to capture larger classes of tractable instances than purely structural parameters like hypertree width and the more general fractional hypertree width (fhtw). Indeed, we show that any class of instances of bounded fhtw also has bounded joinwidth, and that there exist classes of instances of bounded joinwidth and unbounded fhtw, so bounded joinwidth properly generalizes bounded fhtw. We further show that bounded joinwidth also properly generalizes several other known hybrid restrictions, such as fhtw with degree constraints and functional dependencies. In this sense, bounded joinwidth can be seen as a unifying principle that explains the tractability of several seemingly unrelated classes of CSP instances.

Equations

$$\mathsf{jw}(\mathbf{I})$$

$$\mathsf{jw}({\mathbf{I}}_{\omega })$$

Full text

Joinwidth is a hybrid parameter, as it takes both the graphical structure as well as the constraint relations that appear in the instance into account. It has, therefore, the potential to capture larger classes of tractable instances than purely structural parameters like hypertree width and the more general fractional hypertree width (fhtw). Indeed, we show that any class of instances of bounded fhtw also has bounded joinwidth, and that there exist classes of instances of bounded joinwidth and unbounded fhtw, so bounded joinwidth properly generalizes bounded fhtw.

We further show that bounded joinwidth also properly generalizes several other known hybrid restrictions, such as fhtw with degree constraints and functional dependencies. In this sense, bounded joinwidth can be seen as a unifying principle that explains the tractability of several seemingly unrelated classes of CSP instances.

1 Introduction

The Constraint Satisfaction Problem (CSP) is a central and generic computational problem that provides a common framework for many theoretical and practical applications in AI and other areas of Computer Science [34]. An instance of the CSP consists of a collection of variables that must be assigned values subject to constraints, where each constraint is given in terms of a relation whose tuples specify the allowed combinations of values for specified variables.

CSP is NP-complete in general. A central line of research is concerned with the identification of classes of instances for which the CSP can be solved in polynomial time. The two main approaches are to define classes either in terms of the constraint relations that may occur in the instance (syntactic restrictions; see, e.g., [4]), or in terms of the constraint hypergraph associated with the instance (structural restrictions; see, e.g., [20]). There are also several prominent proposals for utilizing simultaneously syntactic and structural restrictions called hybrid restrictions (see, e.g., [30, 7, 8, 6]).

Grohe and Marx [22] showed that CSP is polynomial-time tractable whenever the constraint hypergraph has bounded fractional hypertree width, which strictly generalizes previous tractability results based on hypertree width [17] and acyclic queries [36]. Bounded fractional hypertree width is the most general known structural restriction that gives rise to polynomial-time tractability of CSP.

As bounded fractional hypertree width is a structural restriction that is completely oblivious to the relations present in the instance, it is natural to expect that one can modify fractional hypertree width to take the shape of relations into account. This is indeed possible, but does not lead to a compact notion that is well-suited for further theoretical analysis.

Our contribution: Joinwidth.

We propose a new hybrid restriction for the CSP, the width parameter joinwidth, which is based on the arrangement of basic relational operations along a tree, and not on hypertree decompositions. Interestingly, as we will show, our notion strictly generalizes (i) bounded fractional hypertree width, (ii) recently introduced extensions of fractional hypertree width with degree constraints and functional dependencies [26], (iii) various prominent hybrid restrictions [5], as well as (iv) tractable classes based on functionality and root sets [10, 9, 5]. Hence, joinwidth gives rise to a common framework that captures several different tractable classes considered in the past. Moreover, none of the other hybrid parameters that we are aware of [8], such as classes based on the Broken Triangle Property or topological minors [7, 6] and directional rank [30], generalize fractional hypertree width and hence all of them are either less general or orthogonal to joinwidth.

Joinwidth is based on the arrangement of the constraints on the leaves of a rooted binary tree which we call a join decomposition. The join decomposition indicates the order in which relational joins are formed, where one proceeds in a bottom-up fashion from the leaves to the root, labeling a node by the join of the relations at its children, and projecting away variables that do not occur in relations to be processed later. Join decompositions are related to (structural) branch decompositions of hypergraphs, where the hyperedges are arranged on the leaves of the tree [2, 21, 32]. Related notions have been considered in the context of query optimization [1, 24]. However, the basic form of join decompositions using only relational joins and projections is still a weak notion that cannot be used to tackle instances of bounded fractional hypertree width efficiently. We identify a further operation that—in conjunction with relational joins and projections—gives rise to the powerful new concept of joinwidth that captures and extends the various known tractable classes mentioned. This third operation prunes away all the tuples from an intermediate relation that are inconsistent with a relation to be processed later.

A join decomposition of a CSP instance specifies the order in which the above three operations are applied, and its width is the smallest real number $w$ such that each relation appearing within the join decomposition has at most $m^{w}$ many tuples (where $m$ is the maximum number of tuples appearing in any constraint relation of the CSP instance under consideration). The joinwidth of a CSP instance is the smallest width over all its join decompositions. Observe that joinwidth is a hybrid parameter—it depends on both the graphical structure as well as the constraint relations appearing in the instance.

Exploiting Joinwidth.

Similarly to other width parameters, also the property that a class of CSP instances has bounded joinwidth can only be exploited for CSP solving if a decomposition (in our case a join decomposition) witnessing the bounded width is provided as part of the input. While such a join decomposition can be computed efficiently from a fractional hypertree decomposition or when the CSP instance belongs to a tractable class based on functionality or root sets mentioned earlier, we show that computing an optimal join decomposition is NP-hard in general, mirroring the corresponding NP-hardness of computing optimal fractional hypertree decompositions [15].

However, this obstacle disappears if we move from the viewpoint of polynomial-time tractability to fixed-parameter tractability (FPT). Under the FPT viewpoint, one considers classes of instances $\mathbf{I}$ that can be solved by a fixed-parameter algorithm—an algorithm running in time $f(k)|\mathbf{I}|^{O(1)}$, where $k$ is the parameter (typically the number of variables or constraints), $|\mathbf{I}|$ is the size of the instance, and $f$ is a computable function [16, 18, 19]. We note that it is natural to assume that $k$ is much smaller than $|\mathbf{I}|$ in typical cases. The use of fixed-parameter tractability is well motivated in the CSP setting; see, for instance, Marx’s discussion on this topic [29].

Here, we obtain two single-exponential fixed-parameter algorithms for instances of bounded joinwidth (i.e., algorithms with a running time of $2^{\mathcal{O}(k)}\cdot|\mathbf{I}|^{\mathcal{O}(1)}$): one where $k$ is the number of variables, and the other when $k$ is the number of constraints. In this setting, we do not require an associated join decomposition to be provided with the input.

Under the FPT viewpoint, Marx [29] previously introduced the structural parameter submodular width (bounded submodular width is equivalent to bounded adaptive width [28]), which is strictly more general than fractional hypertree width, but when bounded only gives rise to fixed-parameter tractability and not polynomial-time tractability of CSP. In fact, Marx showed that assuming the Exponential Time Hypothesis [23], bounded submodular width is the most general purely structural restriction that yields fixed-parameter tractability for CSP. However, as joinwidth is a hybrid parameter, it can (and we show that it does) remain bounded even on instances of unbounded submodular width—and the same holds also for the recently introduced extensions of submodular width based on functional dependencies and degree bounds [26].

Roadmap.

After presenting the required preliminaries on (hyper-)graphs, CSP, and fractional hypertree width in Section 2, we introduce and motivate join decompositions and joinwidth in Section 3. We establish some fundamental properties of join decompositions, provide our tractability result for CSP for the case when a join decomposition is given as part of the input, and then obtain our NP-hardness result for computing join decompositions of constant width. Section 4 provides an in-depth justification for the various design choices underlying join decompositions; among others, we show that the pruning step is required if the aim is to generalize fractional hypertree width. Our algorithmic applications for joinwidth are presented in Section 5: for instance, we show that joinwidth generalizes fractional hypertree width, but also other known (and hybrid) parameters such as functionality, root sets, and Turan sets. Section 6 contains our fixed-parameter tractability results for classes of CSP instances with bounded joinwidth. Finally, in Section 7, we compare the algorithmic power of joinwidth to the power of algorithms which rely on the unrestricted use of join and projection operations.

2 Preliminaries

We will use standard graph terminology [12]. An undirected graph $G$ is a pair $(V,E)$, where $V$ or $V(G)$ is the vertex set and $E$ or $E(G)$ is the edge set. All our graphs are simple and loopless. For a tree $T$ we use $L(T)$ to denote the set of its leaves. For $i\in\mathbb{N}$, we let $[i]=\{1,\dots,i\}$.

2.1 Hypergraphs, Branchwidth and Treewidth

Similarly to graphs, a hypergraph $H$ is a pair $(V,E)$ where $V$ or $V(H)$ is its vertex set and $E$ or $E(H)\subseteq 2^{V}$ is its set of hyperedges. We denote by $H[V^{\prime}]$ the hypergraph induced on the vertices in $V^{\prime}\subseteq V$, i.e., the hypergraph with vertex set $V^{\prime}$ and edge set $\{\,e\cap V^{\prime}\;{:}\;e\in E\,\}$.

Every subset $F$ of $E(H)$ defines a cut of $H$, i.e., the pair $(F,E(H)\setminus F)$. We denote by $\mathsf{\delta}_{H}(F)$ (or just $\mathsf{\delta}(F)$ if $H$ is clear from the context) the set of cut vertices of $F$ in $H$, i.e., $\mathsf{\delta}(F)$ contains all vertices incident to both an edge in $F$ and an edge in $E(H)\setminus F$. Note that $\mathsf{\delta}(F)=\mathsf{\delta}(E(H)\setminus F)$.

Let $H$ be a hypergraph. A branch-decomposition of $H$ is a pair $\mathcal{B}=(B,\beta)$, where $B$ is a rooted binary tree and $\beta:L(B)\rightarrow E(H)$ is a bijection between the leaves $L(B)$ of $B$ and the edges of $H$. For simplicity, we write $\beta(B^{\prime})$ to denote the set $\{\,\beta(l)\;{:}\;l\in L(B^{\prime})\,\}$ of edges for a subtree $B^{\prime}$ of $B$. The branchwidth of an edge $e$ of $B$, denoted by $\mathsf{bw}(e)$, is equal to $|\mathsf{\delta}_{H}(\beta(B^{\prime}))|$, where $B^{\prime}$ is any of the two components of $B-e$. The branchwidth of $\mathcal{B}$ is equal to $\max_{e\in E(B)}\mathsf{bw}(e)$ and the branchwidth of $H$, denoted by $\mathsf{bw}(H)$, is the minimum branchwidth of any of its branch-decompositions. We say that $\mathcal{B}$ is a linear branch decomposition if every inner node of $B$ is adjacent to at least one leaf node and define the linear branchwidth of $H$, denoted by $\mathsf{lbw}(H)$, as the minimum branchwidth over all linear branch decompositions of $H$.

A tree-decomposition of $H$ is a pair $\mathcal{T}=(T,(B_{t})_{t\in V(T)})$, where $T$ is a tree and $B_{t}\subseteq V(H)$ for every $t\in V(T)$ such that: (1) for every $e\in E(H)$ there is a $t\in V(T)$ such that $e\subseteq B_{t}$ and (2) for every $v\in V(H)$ the set $\{\,t\in V(T)\;{:}\;v\in B_{t}\,\}$ induces a non-empty subtree of $T$. The treewidth of $\mathcal{T}$ is equal to $\max_{t\in V(T)}(|B_{t}|-1)$, and the treewidth of $H$ is the minimum treewidth of any tree-decomposition of $H$. We say that $\mathcal{T}$ is a path-decomposition if $T$ is a path and define the pathwidth of $H$ as the minimum treewidth of any path-decomposition of $H$.

2.2 The Constraint Satisfaction Problem

Let $D$ be a set and $n$ and $n^{\prime}$ be natural numbers. An $n$-ary relation on $D$ is a subset of $D^{n}$. For a tuple $t\in D^{n}$, we denote by $t[i]$, the $i$-th entry of $t$, where $1\leq i\leq n$. For two tuples $t\in D^{n}$ and $t^{\prime}\in D^{n^{\prime}}$, we denote by $t\circ t^{\prime}$, the concatenation of $t$ and $t^{\prime}$.

An instance of a constraint satisfaction problem (CSP) $\mathbf{I}$ is a triple $\langle{V,D,C}\rangle$, where $V$ is a finite set of variables over a finite set (domain) $D$, and $C$ is a set of constraints. A constraint $c\in C$ consists of a scope, denoted by $S(c)$, which is a completely ordered subset of $V$, and a relation, denoted by $R(c)$, which is a $|S(c)|$-ary relation on $D$. We let $|c|$ denote the number of tuples in $R(c)$ and $|\mathbf{I}|=|V|+|D|+\sum_{c\in C}|c|$. Without loss of generality, we assume that each variable occurs in the scope of at least one constraint.

A solution for $\mathbf{I}$ is an assignment $\theta:V\rightarrow D$ of the variables in $V$ to domain values (from $D$) such that for every constraint $c\in C$ with scope $S(c)=(v_{1},\dotsc,v_{|S(c)|})$, the relation $R$ contains the tuple $\theta(S(c))=(\theta(v_{1}),\dotsc,\theta(v_{|S(c)|}))$. We denote by $\textup{SOL}(\mathbf{I})$ the constraint containing all solutions of $\mathbf{I}$, i.e., the constraint with scope $V=\{v_{1},\dotsc,v_{n}\}$, whose relation contains one tuple $(\theta(v_{1}),\dotsc,\theta(v_{n}))$ for every solution $\theta$ of $\mathbf{I}$. The task in CSP is to decide whether the instance $\mathbf{I}$ has at least one solution or in other words whether $\textup{SOL}(\mathbf{I})\neq\emptyset$. Here and in the following we will for convenience (and with a slight abuse of notation) sometimes treat constraints like sets of tuples.

For a variable $v\in S(c)$ and a tuple $t\in R(c)$, we denote by $t[v]$, the $i$-th entry of $t$, where $i$ is the position of $v$ in $S(c)$. Let $V^{\prime}$ be a subset of $V$ and let $V^{\prime\prime}$ be all the variables that appear in $V^{\prime}$ and $S(c)$. With a slight abuse of notation, we denote by $S(c)\cap V^{\prime}$, the sequence $S(c)$ restricted to the variables in $V^{\prime}$ and we denote by $t[V^{\prime}]$ the tuple $(t[v_{1}],\dotsc,t[v_{|V^{\prime\prime}|}])$, where $S(c)\cap V^{\prime}=(v_{1},\dotsc,v_{|V^{\prime\prime}|})$.

Let $c$ and $c^{\prime}$ be two constraints of $\mathbf{I}$. We denote by $S(c)\cup S(c^{\prime})$, the ordered set (i.e., tuple) $S(c)\circ(S(c^{\prime})\setminus S(c))$. The (natural) join between $c$ and $c^{\prime}$, denoted by $c\Join c^{\prime}$, is the constraint with scope $S(c)\cup S(c^{\prime})$ containing all tuples $t\circ t^{\prime}[S(c^{\prime})\setminus S(c)]$ such that $t\in R(c)$, $t^{\prime}\in R(c^{\prime})$, and $t[S(c)\cap S(c^{\prime})]=t^{\prime}[S(c)\cap S(c^{\prime})]$. The projection of $c$ to $V^{\prime}$, denoted by $\pi_{V^{\prime}}(c)$, is the constraint with scope $S(c)\cap V^{\prime}$, whose relation contains all tuples $t[V^{\prime}]$ with $t\in R(c)$. We note that if $c$ contains at least one tuple, then projecting it onto a set $V^{\prime}$ with $V^{\prime}\cap S(c)=\emptyset$ results in the constraint with an empty scope and a relation containing the empty tuple (i.e., a tautological constraint). On the other hand, if $R(c)$ is the relation containing the empty tuple, then every projection of $c$ will also result in a relation containing the empty tuple.

For a CSP instance $\mathbf{I}=\langle{V,D,C}\rangle$ we sometimes denote by $V(\mathbf{I})$, $D(\mathbf{I})$, $C(\mathbf{I})$, and $\sharp_{\emph{tup}}(\mathbf{I})$ its set of variables $V$, its domain $D$, its set of constraints $C$, and the maximum number of tuples in any constraint relation of $\mathbf{I}$, respectively. For a subset $V^{\prime}\subseteq V$, we will also use $\mathbf{I}[V^{\prime}]$ to denote the sub-instance of $\mathbf{I}$ induced by the variables in $V^{\prime}\subseteq V$, i.e., $\mathbf{I}[V^{\prime}]=\langle{V^{\prime},D,\{\,\pi_{V^{\prime}}(c)\;{:}\;c\in C\,\}}\rangle$. The hypergraph $H(\mathbf{I})$ of a CSP instance $\mathbf{I}=\langle{V,D,C}\rangle$ is the hypergraph with vertex set $V$ and edge set $\{\,S(c)\;{:}\;c\in C\,\}$.

It is well known that for every instance $\mathbf{I}$ and every instance $\mathbf{I}^{\prime}$ obtained by either (1) replacing two constraints in $C(\mathbf{I})$ by their natural join or (2) adding a projection of a constraint in $C(\mathbf{I})$, it holds that $\textup{SOL}(\mathbf{I})=\textup{SOL}(\mathbf{I}^{\prime})$. As a consequence, $\textup{SOL}(\mathbf{I})$ can be computed by performing, e.g., a sequence of joins over all the constraints in $C$.

2.3 Fractional Hypertree Width

Let $H$ be a hypergraph. A fractional edge cover for $H$ is a mapping $\gamma:E(H)\rightarrow\mathbb{R}$ such that $\sum_{e\in E(H)\land v\in e}\gamma(e)\geq 1$ for every $v\in V(H)$. The weight of $\gamma$, denoted by $w(\gamma)$, is the number $\sum_{e\in E(H)}\gamma(e)$. The fractional edge cover number of $H$, denoted by $\mathsf{fec}(H)$, is the smallest weight of any fractional edge cover of $H$.

A fractional hypertree decomposition $\mathcal{T}$ of $H$ is a triple $\mathcal{T}=(T,(B_{t})_{t\in V(T)},$ $(\gamma_{t})_{t\in V(T)})$, where $(T,(B_{t})_{t\in V(T)})$ is a tree decomposition [33, 13] of $H$ and $(\gamma_{t})_{t\in V(T)}$ is a family of mappings from $E(H)$ to $\mathbb{R}$ such that for every $t\in V(T)$, it holds that $\gamma_{t}$ is a fractional edge cover for $H[B_{t}]$. We call the sets $B_{t}$ the bags and the mappings $\gamma_{t}$ the fractional guards of the decomposition. The width of $\mathcal{T}$ is the maximum $w(\gamma_{t})$ over all $t\in V(T)$. The fractional hypertree width of $H$, denoted by $\mathsf{fhtw}(H)$, is the minimum width of any fractional hypertree decomposition of $H$. Finally, the fractional hypertree width of a CSP instance $\mathbf{I}$, denoted by $\mathsf{fhtw}(\mathbf{I})$, is equal to $\mathsf{fhtw}(H(\mathbf{I}))$.

Proposition 1

*Let $\mathbf{I}$ be a CSP instance with hypergraph $H$ and let $\mathcal{T}=(T,(B_{t})_{t\in V(T)},(\gamma_{t})_{t\in V(T)})$ be a fractional hypertree decomposition of $H$ of width at most $\omega$. For every node $t\in V(T)$ and every subset $B\subseteq B_{t}$, it holds that $|\textup{SOL}(\mathbf{I}[B])|\leq(\sharp_{\emph{tup}}(\mathbf{I}))^{\omega}$. *

Proof

It follows from the definition of fractional hypertree width that $\gamma_{t}$ is a fractional edge cover for $H[B_{t}]$ of width at most $\omega$ for every $t\in V(T)$. Since fractional edge covers are heriditary, $\gamma_{t}$ is also a fractional edge cover for $H[B]$ of width at most $\omega$ for every $B\subseteq B_{t}$. Moreover, it is shown in [22, Lemma 3], that any CSP instance $\mathbf{I}^{\prime}$ has at most $(\sharp_{\emph{tup}}(\mathbf{I}^{\prime}))^{\mathsf{fec}(H(\mathbf{I}^{\prime}))}$ solutions; note that [22, Lemma 3] actually only states that $\mathbf{I}^{\prime}$ has at most $(|\mathbf{I}^{\prime}|)^{\mathsf{fec}(H(\mathbf{I}^{\prime}))}$ solutions, however, the slightly stronger bound of $(\sharp_{\emph{tup}}(\mathbf{I}^{\prime}))^{\mathsf{fec}(H(\mathbf{I}^{\prime}))}$ follows immediately from the proof of [22, Lemma 3]. Hence, because $\mathsf{fec}(\mathbf{I}[B])\leq\omega$, we obtain that $\mathbf{I}[B]$ has at most $(\sharp_{\emph{tup}}(\mathbf{I}))^{\omega}$ solutions. ∎

3 Join Decompositions and Joinwidth

This section introduces two notions that are central to our contribution: join decompositions and joinwidth. In the following, let us consider an arbitrary CSP instance $\mathbf{I}=\langle{V,D,C}\rangle$.

Definition 2

A join decomposition for $\mathbf{I}$ is a pair $(J,\varrho)$, where $J$ is a rooted binary tree and $\varrho$ is a bijection between the leaves $L(J)$ of $J$ and $C$.

Let $j$ be a node of $J$. We denote by $J_{j}$ the subtree of $J$ rooted at $j$ and we denote by $X(j)$, $V(j)$, $\overline{V}(j)$, and $S(j)$ the (unordered) sets $\{\,\varrho(\ell)\;{:}\;\ell\in L(J_{j})\,\}$, $\bigcup_{c\in X(j)}S(c)$, $\bigcup_{c\not\in X(j)}S(c)$, and $V(j)\cap\overline{V}(j)$, respectively; infuitively, $X(j)$ is the set of constraints that occur in the subtree rooted at $j$, $V(j)$ is the set of variables that occur in the scope of constraints in $X(j)$, $\overline{V}(j)$ is the set of variables that occur in the scope of constraints not in $X(j)$, and $S(j)$ is the set of variables that occur in $V(j)$ and $\overline{V}(j)$. In some cases, we will also consider linear join decompositions, which are join decompositions where every inner node is adjacent to at least one leaf.

Semantics of Join Decompositions.

Intuitively, every internal node of a join decomposition represents a join operation that is carried out over the constraints obtained for the two children; in this way, a join decomposition can be seen as a procedure for performing joins, with the aim of determining whether $\textup{SOL}(\mathbf{I})$ is non-empty (i.e., solving the CSP instance $\mathbf{I}$). Crucially, the running time of such a procedure depends on the size of the constraints obtained and stored by the algorithm which performs such joins. The aim of this subsection is to formally define and substantiate an algorithmic procedure which uses join decompositions to solve CSP.

The Naive Approach.

A naive way of implementing the above idea would be to simply compute and store the natural join at each node of the join decomposition and proceed up to the root; see for instance the work of [3]. Formally, we can recursively define a constraint $C_{\emph{naive}}(j)$ for every node $j\in V(J)$ as follows. If $j$ is a leaf, then $C_{\emph{naive}}(j)=\varrho(j)$. Otherwise $C_{\emph{naive}}(j)$ is equal to $C_{\emph{naive}}(j_{1})\Join C_{\emph{naive}}(j_{2})$, where $j_{1}$ and $j_{2}$ are the two children of $j$ in $J$. It is easy to see that this approach can create large constraints even for very simple instances of CSP: for example, at the root $r$ of $T$ it holds that $\textup{SOL}(\mathbf{I})=C_{\emph{naive}}(r)$, and hence $C_{\emph{naive}}(r)$ would have superpolynomial size for every instance of CSP with a superpolynomial number of solutions. In particular, an algorithm which computes and stores $C_{\emph{naive}}(j)$ would never run in polynomial time for CSP instances with a superpolynomial number of solutions.

A Better Approach

A more effective way of joining constraints along a join decomposition is to only store projections of constraints onto those variables that are still relevant for constraints which have yet to appear; this idea has been used, e.g., in algorithms which exploit hypertree width [17]. To formalize this, let $C_{\emph{proj}}(j)$ be recursively defined for every node $j\in V(T)$ as follows. If $j$ is a leaf, then $C_{\emph{proj}}(j)=\pi_{\overline{V}(j)}(\varrho(j))$. Otherwise $C_{\emph{proj}}(j)$ is equal to \big{(}\pi_{\overline{V}(j)}(C_{\emph{proj}}(j_{1})\Join C_{\emph{proj}}(j_{2})\big{)}), where $j_{1}$ and $j_{2}$ are the two children of $j$ in $J$. In this case, $\mathbf{I}$ is a YES-instance if and only if $C_{\emph{proj}}(r)$ does not contain the empty relation. Clearly, for every node $j$ of $J$ it holds that $C_{\emph{proj}}(j)$ has at most as many tuples as $C_{\emph{naive}}(j)$, but can have arbitrarily fewer tuples; in particular, an algorithm which uses join decompositions to compute $C_{\emph{proj}}$ in a bottom-up fashion can solve CSP instances in polynomial time even if they have a superpolynomial number of solutions (see also Observation 8).

However, the above approach still does not capture the algorithmic power offered by dynamically computing joins along a join decomposition. In particular, similarly as has been done in the evaluation algorithm for fractional edge cover [22, Theorem 3.5], we can further reduce the size of each constraint $C_{\emph{proj}}(j)$ computed in the above procedure by pruning all tuples that would immediately violate a constraint $c$ in $\mathbf{I}$ (and, in particular, in $C\setminus C(j)$). To formalize this operation, we let $\textsf{prune}(c)$ denote the pruned constraint w.r.t. $\mathbf{I}$, i.e., $\textsf{prune}(c)$ is obtained from $c$ by removing all tuples $t\in R(c)$ such that there is a constraint $c^{\prime}\in C$ with $t[S(c^{\prime})]\notin\pi_{S(c)}(c^{\prime})$. This leads us to our final notion of dynamically computed constraints: for a node $j$, we let $C(j)=\textsf{prune}(C_{\emph{proj}}(j))$. We note that this, perhaps inconspicuous, notion of pruning is in fact critical—without it, one cannot use join decompositions to efficiently solve instances of small fractional hypertree width or even small fractional edge cover. A more in-depth discussion on this topic is provided in Section 4.

We can now proceed to formally define the considered width measures.

Definition 3

Let $\mathcal{J}=(J,\varrho)$ be a join decomposition for $\mathbf{I}$ and let $j\in V(J)$. The joinwidth of $j$, denoted $\mathsf{jw}(j)$, is the smallest real number $\omega$ such that $|C(j)|\leq(\sharp_{\emph{tup}}(\mathbf{I}))^{\omega}$, i.e., $\omega=\log_{\sharp_{\emph{tup}}(\mathbf{I})}|C(j)|$. The joinwidth of $\mathcal{J}$ (denoted $\mathsf{jw}(\mathcal{J})$) is then the maximum $\mathsf{jw}(j)$ over all $j\in V(J)$. Finally, the joinwidth of $\mathbf{I}$ (denoted $\mathsf{jw}(\mathbf{I})$) is the minimum $\mathsf{jw}(\mathcal{J})$ over all join decompositions $\mathcal{J}$ for $\mathbf{I}$.

In general terms, an instance $\mathbf{I}$ has joinwidth $\omega$ if it admits a join decomposition where the number of tuples of the produced constraints never increases beyond the $\omega$-th power of the size of the largest relation in $\mathbf{I}$. Analogously as above, we denote by $\mathsf{ljw}(\mathbf{I})$ the minimum joinwidth of any linear join decomposition of a CSP instance $\mathbf{I}$.

Example 4

*Let $N\in\mathbb{N}$ and consider the CSP instance $\mathbf{I}$ having three variables $a$, $b$, and $c$ and three constraints $x$, $y$, and $z$ with scopes $(a,b)$, $(b,c)$, and $(a,c)$, respectively. Assume furthermore that the relations of all three constraints are identical and contain all tuples $(1,i)$ and $(i,1)$ for every $i\in[N]$. Refer also to Figure 1 for an illustration of the example. Then $|x|=|y|=|z|=\sharp_{\emph{tup}}(\mathbf{I})=2N-1$ and due to the symmetry of $\mathbf{I}$ any join-tree $\mathcal{J}$ of $\mathbf{I}$ has the same joinwidth, which (as we will show) is equal to $1$. To see this consider for instance the join-tree $\mathcal{J}$ that has one inner node $j$ joining $x$ and $y$ and a root node $r$ joining $C(j)$ and $z$. Then $\mathsf{jw}(\ell)=1$ for any leaf node $\ell$ of $\mathcal{J}$. Moreover $|C(j)|=|\textsf{prune}(C_{\emph{proj}}(j))|=|z|=\sharp_{\emph{tup}}(\mathbf{I})$ since the pruning step removes all tuples from $C_{\emph{proj}}(j)$ that are not in $z$ and consequently $C(r)=z$ and $\mathsf{jw}(\mathcal{J})=1$. Note that in this example $\mathsf{jw}(\mathbf{I})=1<\mathsf{fhtw}(\mathbf{I})=3/2$. *

Finally, we remark that one could in principle also define joinwidth in terms of a (rather tedious and technically involved) variant of hypertree decompositions. However, the inherent algorithmic nature of join-trees makes them much better suited for the definition of joinwidth.

Properties of Join Decompositions.

Our first task is to formalize the intuition behind the constraints $C(j)$ computed when proceeding through the join tree.

Lemma 5

Let $(J,\varrho)$ be a join decomposition for $\mathbf{I}=\langle{V,D,C}\rangle$ and let $j\in V(J)$. Then $C(j)=\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}^{\prime}))$, where $\mathbf{I}^{\prime}=\mathbf{I}[V(j)]$.

Proof

We prove the lemma by leaf-to-root induction along $J$. If $j$ is a leaf such that $\varrho(j)=c$, then $C(j)$ is the constraint obtained from $c$ by projecting onto $\overline{V}(j)$ and then applying pruning with respect to $\mathbf{I}$. Crucially, pruning $c$ w.r.t. $\mathbf{I}^{\prime}$ produces the same result as pruning $c$ w.r.t. $\mathbf{I}$. Since pruning cannot remove tuples which occur in $\textup{SOL}(\mathbf{I}^{\prime})$, each tuple in $\textup{SOL}(\mathbf{I}^{\prime})$ must also occur in $C(j)$ (as a projection onto $\overline{V}(j)$). On the other hand, consider a tuple $\alpha$ in $C(j)$ and assume for a contradiction that $\alpha$ is not present in $\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}^{\prime}))$. Since variables outside of $\overline{V}(j)$ do not occur in the scopes of constraints other than $c$, this means that there would exist a constraint $c^{\prime}$ in $\mathbf{I}^{\prime}$ which is not satisfied by an assignment corresponding to $\alpha$—but in that case $\alpha$ would be removed from $C(j)$ via pruning. Hence $C(j)=\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}^{\prime}))$ holds for every leaf in $T$.

For the induction step, consider a node $j$ with children $j_{1}$ and $j_{2}$ (with their corresponding instances being $\mathbf{I}^{\prime}_{1}$ and $\mathbf{I}^{\prime}_{2}$, respectively), and recall that $C(j)$ is obtained from $C(j_{1})\Join C(j_{2})$ by projecting onto $\overline{V}(j)$ and then pruning (w.r.t. $\mathbf{I}$ or, equivalently, w.r.t. $\mathbf{I}^{\prime}$). We will also implicitly use the fact that $\overline{V}(j)\subseteq\overline{V}(j_{1})\cup\overline{V}(j_{2})$ and $V(j)=V(j_{1})\cup V(j_{2})$. First, consider for a contradiction that there exists a tuple $\beta$ in $\textup{SOL}(\mathbf{I}^{\prime}[\overline{V}(j)])$ which does not occur in $C(j)$. Clearly, $\beta$ could not have been removed by pruning, and hence this would mean that there exists no tuple in $C(j_{1})\Join C(j_{2})$ which results in $\beta$ after projection onto $\overline{V}(j)$; in particular, w.l.o.g. we may assume that every tuple in $C(j_{1})$ differs from $\beta$ in (the assignment of) at least one variable. However, since $\beta$ occurs in $\textup{SOL}(\mathbf{I}^{\prime}[\overline{V}(j)])$, there must exist at least one tuple, say $\beta^{\prime}$, which occurs in $\textup{SOL}(\mathbf{I}^{\prime})$, and consequently there exists a tuple in $\textup{SOL}(\mathbf{I}_{1}^{\prime})$ which matches $\beta$ in (the assignment of) all variables. At this point, we have reached a contradiction with the inductive assumption that $\textup{SOL}(\mathbf{I}_{1}^{\prime}[\overline{V}(j_{1})])=C(j_{1})$.

For the final case, consider a tuple $\gamma$ in $C(j)$ and assume for a contradiction that $\gamma$ is not present in $\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}^{\prime}))$. This means that there exists at least one constraint, say $c^{\prime}$, in $\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}^{\prime}))$ which would be invalidated by (an assignment corresponding to) $\gamma$. Let us assume that $c^{\prime}$ occurs in the subtree rooted in $j_{2}$, and let $\gamma_{1}$ be an arbitrary “projection” of $\gamma$ onto $\overline{V}(j_{1})$. Since $\overline{V}(j_{1})\supseteq S(c^{\prime})$, this means that $\gamma_{1}$ would have been removed from $C(j_{1})$ by pruning; in particular, we see that there exists no tuple $\gamma_{1}$ in $C(j_{1})$ which could produce $\gamma$ in a join, contradicting our assumptions about $\gamma$. By putting everything together, we conclude that indeed $C(j)=\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}^{\prime}))$. ∎

Next, we show how join decompositions can be used to solve CSP.

Theorem 6

CSP* can be solved in time $\mathcal{O}(|\mathbf{I}|^{2\omega+4})$ provided that a join decomposition of width at most $\omega$ is given in the input.*

Proof

Let $\mathcal{J}=(J,\varrho)$ be the provided join decomposition of width $\omega$ for $\mathbf{I}$. As noted before, the algorithm for solving $\mathbf{I}$ computes $C(j)$ for every $j\in V(J)$ in a bottom-up manner. Since $J$ has exactly $2|C|-1$ nodes, it remains to analyse the maximum time required to compute $C(j)$ for any node of $J$. If $j$ is a leaf, then $C(j)=\textsf{prune}(\pi_{S(j)}(\varrho(j)))$ and since the time required to compute the projection $P=\pi_{S(j)}(\varrho(j))$ from $\varrho(j)$ is at most $\mathcal{O}(\sharp_{\emph{tup}}(\mathbf{I})|S(j)|)$ and the time required to compute the pruned constraint $\textsf{prune}(P)$ from $P$ is at most $\mathcal{O}(|C|(\sharp_{\emph{tup}}(\mathbf{I}))^{2}|S(j)|)$, we obtain that $C(j)$ can be computed in time $\mathcal{O}(|C|(\sharp_{\emph{tup}}(\mathbf{I}))^{2}|S(j)|)\in\mathcal{O}(|\mathbf{I}|^{4})$. Moreover, if $j$ is an inner node with children $j_{1}$ and $j_{2}$, then $C(j)=\textsf{prune}(\pi_{S(j)}(C(j_{1})\Join C(j_{2})))$ and since we require at most $\mathcal{O}((\sharp_{\emph{tup}}(\mathbf{I}))^{2\omega}|S(j_{1})\cup S(j_{2})|)$ time to compute the join $Q=C(j_{1})\Join C(j_{2})$ from $C(j_{1})$ and $C(j_{2})$, at most $\mathcal{O}((\sharp_{\emph{tup}}(\mathbf{I}))^{2\omega}|S(j)|)$ time to compute the projection $P=\pi_{S(j)}(Q)$ from $Q$, and at most $\mathcal{O}(|C|(\sharp_{\emph{tup}}(\mathbf{I}))^{2\omega+1}\cdot|S(j)|)$ time to compute the pruned constraint $\textsf{prune}(P)$ from $P$, we obtain $\mathcal{O}(|C|(\sharp_{\emph{tup}}(\mathbf{I}))^{2\omega+1}\cdot|S(j_{1})\cup S(j_{2})|)=\mathcal{O}(|\mathbf{I}|^{2\omega+3})$ as the total time required to compute $C(j)$. Multiplying the time required to compute $C(j)$ for an inner node $j\in V(J)$ with the number of nodes of $T$ yields the running time stated in the lemma. ∎

Computing Join Decompositions.

Next, let us address the problem of computing join decompositions of bounded joinwidth, formalized as follows.

$\omega$-Join Decomposition

Input: A CSP instance $\mathbf{I}$.

Question: Compute a join decomposition for $\mathbf{I}$ of width at most $\omega$, or correctly determine that $\mathsf{jw}(\mathbf{I})>\omega$.

We show that $\omega$-Join Decomposition is NP-hard even for width $\omega=1$. This is similar to fractional hypertree width, where it was only very recently shown that deciding whether $\mathsf{fhtw}(\mathbf{I})\leq 2$ is NP-hard [15], settling a question which had been open for about a decade. Our proof is, however, entirely different from the corresponding hardness proof for fractional hypertree width and uses a reduction from the NP-complete Branchwidth problem [35].

Theorem 7

$1$-Join Decomposition is NP-hard, even on Boolean CSP instances.

Proof

We will reduce from the well-established NP-complete Branchwidth problem, which given a graph $G$ and an integer $\omega$ asks, whether $G$ has branchwidth at most $\omega$. Let $(G,\omega)$ be an instance of the Branchwidth problem. We will first show how to construct a ternary CSP instance $\mathbf{I}=(V,D,C)$ such that $\mathsf{bw}(G)\leq\omega$ if and only if $\mathsf{jw}(\mathbf{I})\leq\log_{|V(G)|+2}|V(G)|+\omega\leq 2$; we will then later explain how to adapt the construction of $\mathbf{I}$ to make its domain boolean and to reduce the required joinwidth to $1$. Let $V(G)=\{v_{1},\dotsc,v_{n}\}$. We set:

• •

$V=V(G)\cup\{a\}$,

• •

$D=\{1,\cdots,n\}$,

• •

for every $e=\{v_{i},v_{j}\}\in E(G)$, $\mathbf{I}$ has a constraint $c_{e}$ with scope $(a,v_{i},v_{j})$ whose relation $R(c_{e})$ contains every tuple $t$ such that:

• –

$t[a]\in\{1,\cdots,n\}$,

• –

for $l\in\{i,j\}$, it holds that $t[v_{l}]\in\{1,2\}$ if $t[a]=l$ and $t[v_{l}]=1$ otherwise.

Note that $\sharp_{\emph{tup}}(\mathbf{I})=n+2$. Since $\mathbf{I}$ can clearly be constructed in polynomial time it only remains to show that $\mathsf{bw}(G)\leq\omega$ if and only if $\mathsf{jw}(\mathbf{I})\leq\log_{n+2}(n+\omega)\leq 2$.

Towards showing the forward direction, let $\mathcal{B}=(B,\beta)$ be a branch decomposition for $G$ of width at most $\omega$. We claim that $\mathcal{J}=(B,\varrho)$, where $\varrho(l)=c_{\beta(l)}$ for every $l\in L(B)$, is a join decomposition for $\mathbf{I}$ of width at most $\log_{n+2}(n+\omega)$. Consider any node $j\in V(B)$, then $S(j)=\mathsf{\delta}(B_{j})\cup\{a\}$, moreover, the constraint $C(j)$ contains every tuple $t$ such that:

• •

$t[a]\in\{1,\cdots,n\}$,

• •

for every $v_{i}\in S(j)\setminus\{a\}$, it holds that $t[v_{i}]\in\{1,2\}$ if $t[a]=i$ and $t[v_{i}]=1$ otherwise.

Hence $\mathsf{jw}(j)=\log_{\sharp_{\emph{tup}}(\mathbf{I})}|C(j)|=\log_{n+2}(n+|\mathsf{\delta}(j)|)\leq\log_{n+2}(n+\omega)$. Since this holds for every $j\in V(J)$, we obtain that $\mathsf{jw}(\mathcal{J})=\log_{n+2}(n+\omega)$, as required.

Towards showing the reverse direction, let $\mathcal{J}=(J,\varrho)$ be a join decomposition for $\mathbf{I}$ of width at most $\log_{n+2}(n+\omega)$. We claim that $\mathcal{B}=(J,\beta)$, where $\beta(l)=e$ if $\varrho(l)=c_{e}$ for every $l\in L(B)$, is a branch decomposition for $G$ of width at most $\omega$. Consider any node $j\in V(J)$, then $\mathsf{\delta}(B_{j})=S(j)\setminus\{a\}$, moreover, the constraint $C(j)$ contains every tuple $t$ such that:

• •

$t[a]\in\{1,\cdots,n\}$,

• •

for every $v_{i}\in S(j)\setminus\{a\}$, it holds that $t[v_{i}]\in\{1,2\}$ if $t[a]=i$ and $t[v_{i}]=1$ otherwise.

Hence $|C(j)|=n+|\mathsf{\delta}(j)|$, which because $|C(j)|\leq(\sharp_{\emph{tup}}(\mathbf{I}))^{\log_{\sharp_{\emph{tup}}(\mathbf{I})}(n+\omega)}=n+\omega$ implies that $|\mathsf{\delta}(j)|\leq\omega$. Since this holds for every node $j\in V(J)$, we obtain that $\mathsf{bw}(G)\leq\omega$, as required. The completes the first part of the proof. We will now show how to adapt the construction of $\mathbf{I}$ in such a way that $\mathsf{bw}(G)\leq\omega$ if and only $\mathsf{jw}(\mathbf{I})\leq 1$. The idea is to artificially increase $\sharp_{\emph{tup}}(\mathbf{I})$ from $n+2$ to $n+\omega$ without changing the properties of $\mathbf{I}$ too much. To achieve this we simply introduce a new variable $b$ with domain $\{1,\dotsc,n+\omega\}$ and add the complete constraint $c$ with scope $(b)$. It is easy to see that the reduction still works for this slightly modified CSP instance and moreover we obtain that $\mathsf{bw}(G)\leq\omega$ if and only if $\mathsf{jw}(\mathcal{J})=\log_{n+\omega}n+\omega=1$.

Finally, it is easy to convert $\mathbf{I}$ into a boolean CSP instance by replacing the variables $a$ and $b$ with $\log n$ respectively $\log n+\omega$ boolean variables. ∎

Partial Join Decompositions.

Our final task in this section is to introduce the concept of partial join decompositions, which will serve as a useful tool in later sections. Let $\mathbf{I}=(V,D,C)$ be a CSP instance and let $\mathcal{J}=(J,\varrho)$ be a join decomposition for $\mathbf{I}$. We say that $\mathcal{J}^{\prime}=(J_{j},\varrho_{j})$ is a partial join decomposition of $\mathcal{J}$ if $j\in V(J)$ and $\varrho_{j}$ is the restriction of $\varrho$ to $L(J_{j})$. Note that the semantics of $\mathcal{J}^{\prime}$, i.e., the notions $C(j)$ as well as $\mathsf{jw}(j)$ (for every node $j\in V(J_{j})$, are independent of the concrete join decomposition $\mathcal{J}$, but only depend on $\mathcal{J}^{\prime}$ and $\mathbf{I}$. We therefore say that $\mathcal{J}^{\prime}$ is a partial join decomposition for $\mathbf{I}$ covering the constraints in $C^{\prime}\subseteq C$ if $\varrho(L(J_{j}))=C^{\prime}$; assuming that the semantics for every node $j\in V(J_{j})$ are defined as if $\mathcal{J}^{\prime}$ would be part of an arbitrary join decomposition for $\mathbf{I}$.

4 Justifying Joinwidth

Below, we substantiate the use of both pruning and projections in our definition of join decomposition. In particular, we show that using pruning and projections allows the joinwidth to be significantly lower than if we were to consider joins carried out via $C_{\emph{naive}}$ or $C_{\emph{proj}}$. More importantly, we show that join decompositions without pruning do not cover CSP instances with bounded fractional edge cover (and by extension bounded fractional hypertree width). To formalize this, let $\mathsf{jw}_{\emph{naive}}(\mathbf{I})$ and $\mathsf{jw}_{\emph{proj}}(\mathbf{I})$ be defined analogously as $\mathsf{jw}(\mathbf{I})$, with the distinction being that these measure the width in terms of $C_{\emph{naive}}$ and $C_{\emph{proj}}$ instead of $C$.

We also justify the use of trees for join decompositions by showing that there is an arbitrary difference between linear join decompositions (which precisely correspond to simple sequences of joins) and join decompositions.

Observation 8

For every integer $\omega$ there exists a CSP instance $\mathbf{I}_{\omega}$ such that $\mathsf{jw}_{\emph{proj}}(\mathbf{I}_{\omega})\leq 1$, but $\mathsf{jw}_{\emph{naive}}(\mathbf{I}_{\omega})\geq\omega$.

Proof

Consider the CSP instance $\mathbf{I}_{\omega}$ with variables $x,v_{1},\dots,v_{\omega}$ and for each $i\in[\omega]$ a constraint $c_{i}$ with scope $\{x,v_{i}\}$ containing the tuples $\langle{0,1}\rangle$ and $\langle{0,0}\rangle$. Since $\textup{SOL}(\mathbf{I}_{\omega})$ contains $2^{\omega}$ tuples, it follows that every join decomposition with root $r$ must have $|C(r)_{\emph{naive}}|=(\sharp_{\emph{tup}}(\mathbf{I}))^{\omega}=2^{\omega}$ tuples, hence $\mathsf{jw}_{\emph{naive}}(\mathbf{I}_{\omega})\geq\omega$.

On the other hand, consider a linear join decomposition which introduces the constraints in an arbitrary order. Then for each inner node $j$, it holds that $S(j)=\{x\}$ and in particular $C_{\emph{proj}}(j)$ contains a single tuple $(0)$ over scope $\{x\}$. We conclude that $\mathsf{jw}_{\emph{proj}}(\mathbf{I}_{\omega})\leq 1$. ∎

Towards showing that linear joinwidth differs from joinwidth in an arbitrary manner, we will use the following lemma, which establishes a tight relationship between the (linear) joinwidth of a CSP instance and the branchwidth of its hypergraph when all constraints of the CSP instance are complete, i.e., their relations contain all possible tuples.

Lemma 9

Let $\mathbf{I}=\langle{V,D,C}\rangle$ be CSP instance that has only complete constraints. Then $\mathsf{jw}(\mathbf{I})=\mathsf{bw}(H(\mathbf{I}))/2$ and $\mathsf{ljw}(\mathbf{I})=\mathsf{lbw}(H(\mathbf{I}))$.

Proof

Let $\mathbf{I}=\langle{V,D,C}\rangle$ be the given CSP instance with hypergraph $H=H(\mathbf{I})$. First note that any join decomposition $\mathcal{J}=(J,\varrho)$ for $\mathbf{I}$ is also a branch decomposition for $H$, whose width is equal to $\max_{j\in V(J)}|S(j)|$. Conversely, any branch decomposition of $H$ is also a join decomposition for $\mathbf{I}$. Moreover, because all constraints of $\mathbf{I}$ are complete, we have that $C(j)$ is equal to the complete constraint on $|S(j)|$ variables for every node $j$ in a join decomposition $\mathcal{J}=(J,\varrho)$ for $\mathbf{I}$. Hence,

[TABLE]

The proof for the linear versions of join decompositions and branch decompositions is analogous. ∎

Using the above Lemma we are now ready to establish an arbitrary difference between join decompositions and linear join decompositions.

Proposition 10

For every integer $\omega$ there exists a CSP instance $\mathbf{I}_{\omega}$ such that $\mathsf{jw}(\mathbf{I}_{\omega})\leq 1$ but $\mathsf{ljw}(\mathbf{I}_{\omega})\geq\omega$.

Proof

It is well known that trees have branchwidth one but can have arbitrarily high pathwidth [11]. Since pathwidth is known to be within a constant factor of linear branchwidth [31], we obtain that for every $\omega$, there is a tree $T_{\omega}$ with $\mathsf{bw}(T_{\omega})\leq 1$ but $\mathsf{lbw}(T_{\omega})\geq\omega$. Now let $\mathbf{I}_{\omega}$ be the (boolean) CSP instance containing only full binary constraints such that $H(\mathbf{I}_{\omega})=T_{2\omega}$. Then because of Lemma 9 we have that $\mathsf{jw}(\mathbf{I}_{\omega})=\mathsf{bw}(T_{2\omega})/2=0.5\leq 1$ and $\mathsf{ljw}(\mathbf{I}_{\omega})=\mathsf{lbw}(T_{2\omega})/2=\omega$, as required. ∎

The next proposition is by far the most technically challenging of the three, and requires notions which will only be introduced later on. For this reason, we postpone its proof to the end of Subsection 5.1. The proposition shows not only that pruning can significantly reduce the size of stored constraints, but also that without pruning (i.e., with projections alone) one cannot hope to generalize structural parameters such as fractional hypertree width.

Proposition 11

For every integer $\omega$ there exists a CSP instance $\mathbf{I}_{\omega}$ with hypergraph $H^{\omega}$ such that $\mathsf{jw}(\mathbf{I}_{\omega})\leq 2$ and $\mathsf{fec}(H^{\omega})\leq 2$ (and hence also $\mathsf{fhtw}(H^{\omega})\leq 2$), but $\mathsf{jw}_{\emph{proj}}(\mathbf{I}_{\omega})\geq\omega$.

We believe that the above results are of general interest, as they provide useful insights into how to best utilize the joining of constraints.

5 Tractable Classes

Here, we show that join decompositions of small width not only allow us to solve a wide range of CSP instances, but also provide a unifying reason for the tractability of previously established structural parameters and tractable classes.

5.1 Fractional Hypertree Width

We begin by showing that joinwidth is a strictly more general parameter than fractional hypertree width. We start with a simple example showing that the joinwidth of a CSP instance can be arbitrarily smaller than its fractional hypertree width. Indeed, this holds for any structural parameter $\psi$ measured purely on the hypergraph representation, i.e., we say that $\psi$ is a structural parameter if $\psi(\mathbf{I})=\psi(H(\mathbf{I}))$ for any CSP instance $\mathbf{I}$. Examples for structural parameters include fractional and generalized hypertree width, but also submodular width [29].

Observation 12

Let $\psi$ be any structural parameter such that for every $\omega$ there is a CSP instance with $\psi(\mathbf{I})=\psi(H(\mathbf{I}))\geq\omega$. Then for every $\omega$ there is a CSP instance $\mathbf{I}_{\omega}$ with $\mathsf{jw}(\mathbf{I}_{\omega})\leq 1$ but $\psi(\mathbf{I}_{\omega})\geq\omega$.

Proof

Let $H_{\omega}$ be any hypergraph with $\psi(H_{\omega})\geq\omega$. Then the CSP instance $\mathbf{I}_{\omega}$ obtained from $H_{\omega}$ by replacing every hyperedge with an empty constraint satisfies $\psi(\mathbf{I}_{\omega})\geq\omega$ and $\mathsf{jw}(\mathbf{I}_{\omega})\leq 1$. ∎

Note that it is straightforward to construct more interesting examples that also show an arbitrary difference between joinwidth and the recently introduced extensions of fractional hypertree width (or even submodular width) with degree constraints and functional dependencies [26]. For instance, when comparing joinwidth with fractional hypertree width, there are many possibilities to fill the constrains in such a way that the join-width remains low and every such possibility leads to a new example showing the difference between these two width measures. To ensure this it would, e.g., be sufficient to ensure that every set of constrains that appear together in a bag of a fractional hypertree decomposition have small join-width; one such example is given in Proposition 11. The following theorem shows that, for the case of fractional hypertree width, the opposite of the above observation is not true.

Theorem 13

For every CSP instance $\mathbf{I}$, it holds that $\mathsf{jw}(\mathbf{I})\leq\mathsf{fhtw}(\mathbf{I})$.

Proof

Let $H$ be the hypergraph of the given CSP instance $\mathbf{I}=(V,D,C)$ and let $\mathcal{T}=(T,(B_{t})_{t\in V(T)},(\gamma_{t})_{t\in V(T)})$ be an optimal fractional hypertree decomposition of $H$. We prove the theorem by constructing a join decomposition $\mathcal{J}=(J,\varrho)$ for $\mathbf{I}$, whose width is at most $\mathsf{fhtw}(H)$. Let $\alpha:E(H)\rightarrow V(T)$ be some function from the edges of $H$ to the nodes of $T$ such that $e\subseteq B_{\alpha(e)}$ for every $e\in E(H)$. Note that such a function always exists, because $(T,(B_{t})_{t\in V(T)})$ is a tree decomposition of $H$. We denote by $\alpha^{-1}(t)$ the set $\{\,e\in E(H)\;{:}\;\alpha(e)=t\,\}$.

The construction of $\mathcal{J}$ now proceeds in two steps. First we construct a partial join decomposition $\mathcal{J}^{t}=(J^{t},\varrho^{t})$ for $\mathbf{I}$ that covers only the constraints in $\alpha^{-1}(t)$, for every $t\in V(T)$. Second, we show how to combine all the partial join decompositions into the join decomposition $\mathcal{J}$ for $\mathbf{I}$ of width at most $\mathsf{fhtw}(H)$.

Let $t\in V(T)$ and let $\mathcal{J}^{t}=(J^{t},\varrho^{t})$ be an arbitrary partial join decomposition for $\mathbf{I}$ that covers the constraints in $\alpha^{-1}(t)$. Let us consider an arbitrary node $j\in V(J^{t})$. By Lemma 5, we know that $C(j)=\pi_{S(j)}(\textup{SOL}(\mathbf{I}[V(j)]))$. Moreover, the fact that $\bigcup_{e\in\alpha^{-1}(t)}e\subseteq B_{t}$ implies $V(j)\subseteq B_{t}$. Since $|\pi_{S(j)}(\textup{SOL}(\mathbf{I}[V(j)]))|\leq|\textup{SOL}(\mathbf{I}[V(j)])|$, by invoking Proposition 1 we obtain that $|C(j)|\leq|\textup{SOL}(\mathbf{I}[V(j)])|\leq\sharp_{\emph{tup}}(\mathbf{I})^{\mathsf{fhtw}(\mathbf{I})}$. Hence we conclude that $\mathsf{jw}(j)\leq\mathsf{fhtw}(H)$.

Next, we show how to combine the partial join decompositions $\mathcal{J}^{t}$ into the join decomposition $\mathcal{J}$ for $\mathbf{I}$. We will do this via a bottom-up algorithm that computes a (combined) partial join decomposition $\mathcal{F}^{t}=(F^{t},\rho^{t})$ (for every node $t\in V(T)$) that covers all constraints in $\alpha^{-1}(T_{t})=\bigcup_{t\in V(T)}\alpha^{-1}(t)$. Initially, we set $\mathcal{F}^{l}=\mathcal{J}^{l}$ for every leaf $l\in L(T)$. For a non-leaf $t\in V(T)$ with children $t_{1},\dotsc,t_{\ell}$ in $T$, we obtain $\mathcal{F}^{t}$ from the already computed partial join decompositions $\mathcal{F}^{t_{1}},\dotsc,\mathcal{F}^{t_{\ell}}$ as follows. Let $P$ be a path on the new vertices $p_{1},\dotsc,p_{\ell}$ and let $r_{t}$ and $r_{t_{1}},\dotsc,r_{t_{\ell}}$ be the root nodes of $J^{t}$ and $F^{t_{1}},\dotsc,F^{t_{\ell}}$, respectively. Then we obtain $F^{t}$ from the disjoint union of $P$, $J^{t}$, $F^{t_{1}},\dotsc,F^{t_{\ell}}$ after adding an edge between $r_{t}$ and $p_{1}$ and an edge between $r_{t_{i}}$ and $p_{i}$ for every $i$ with $1\leq i\leq\ell$ and setting $p_{\ell}$ to be the root of $F^{t}$. Moreover, $\rho^{t}$ is obtained as the combination (i.e., union) of the functions $\varrho^{t}$, $\rho^{t_{1}},\dotsc,\rho^{t_{\ell}}$. Observe that because $\alpha$ assigns every hyperedge to precisely one bag of $T$, it holds that every constraint assigned to $T_{t}$ is mapped to precisely one leaf of $\mathcal{F}^{t}$. At this point, all that remains is to show that $\mathcal{F}^{t}$ has joinwidth at most $\mathsf{fhtw}(H)$.

Since we have already argued that $|\textup{SOL}(\mathbf{I}[V(j)])|\leq\sharp_{\emph{tup}}(\mathbf{I})^{\mathsf{fhtw}(H)}$ for every node $j$ of $\mathcal{J}^{t}$ and moreover we can assume that the same holds for every node $j$ of $\mathcal{F}^{t_{1}},\dotsc,\mathcal{F}^{t_{\ell}}$ by the induction hypothesis, it only remains to show that the same holds for the nodes $p_{1},\dotsc,p_{\ell}$. First, observe that since $(T,(B_{t})_{t\in V(T)})$ is a tree decomposition of $H$, it holds that $S(r_{t}),S(r_{t_{1}}),\dotsc,S(r_{t_{\ell}})\subseteq B_{t}$. Indeed, consider for a contradiction that, w.l.o.g., there exists a variable $x\in S(r_{t_{1}})\setminus B_{t}$. Then there must exist a hyperedge $e_{1}\ni x$ mapped to $t_{1}$ or one of its descendants, and another hyperedge $e_{i}\ni x$ mapped to some node $t^{\prime}$ that is neither $t_{1}$ nor one of its descendants. But then both $B_{t^{\prime}}$ and $B_{t_{1}}$ must contain $x$, and so $B_{t}$ must contain $x$ as well. Moreover, since $S(p_{i})\subseteq(S(r_{t})\cup S(r_{t_{1}})\cup\dots\cup S(r_{t_{\ell}}))$ for every $i\in[\ell]$, it follows that $S(p_{i})\subseteq B_{t}$ as well.

Finally, recall that $C(p_{i})=\pi_{S(p_{i})}(\textup{SOL}(\mathbf{I}[V(p_{i})]))$ by Lemma 5, and observe that $|\pi_{S(p_{i})}(\textup{SOL}(\mathbf{I}[V(p_{i})]))|\leq|\textup{SOL}(\mathbf{I}[S(p_{i})])|$. Then by Proposition 1 combined with the fact that $S(p_{i})\subseteq B_{t}$, we obtain $|C(p_{i})|\leq|\textup{SOL}(\mathbf{I}[S(p_{i})])|\leq\sharp_{\emph{tup}}(\mathbf{I})^{\mathsf{fhtw}(H)}$, which implies that the width of $p_{i}$ is indeed at most $\mathsf{fhtw}(H)$. ∎

Since we have now established the relationship between joinwidth and fractional hypertree width, we can conclude this subsection with a proof of Proposition 11 (cf. Section 4).

Proof (Proof of Proposition 11)

The proof uses an adaptation of a construction given by Atserias, Grohe and Marx [3, Theorem 7]. Let $m=4\omega+1$ and $n=\binom{2m}{m}$. The CSP instance $\mathbf{I}_{\omega}$ has:

• •

one variable $v_{S}$ for every $S\subseteq[2m]$ with $|S|=m$,

• •

one constraint $c_{i}$ for every $i$ with $1\leq i\leq 2m$ with scope $\{\,v_{S}\;{:}\;i\in S\,\}$. The relation of $c_{i}$ contains the following tuples $t$ for every $v\in S(c_{i})$: every tuple $t$ such that $t[v]\in[n]$ and $t[u]=1$ for every $u\neq v$,

• •

domain $[n]$.

Let $H$ be the hypergraph of $\mathbf{I}_{\omega}$. Note first that $H$ has $n$ vertices, $2m$ edges, every edge of $H$ has size $\binom{2m-1}{m-1}=n/2$, every vertex of $H$ occurs in exactly $m$ edges, and every set of at most $m$ edges of $H$ misses at least one vertex, i.e., the union of at most $m$ edges of $H$ misses at least one vertex from $V(H)$. Note furthermore that $\sharp_{\emph{tup}}(\mathbf{I}_{\omega})=\frac{n^{2}}{2}$.

It is shown in [3, Theorem 4] that $H$ has a fractional edge cover of size at most $2$. This is witnessed by the mapping $\gamma:E(H)\rightarrow\mathbb{R}$ defined by setting $\gamma(e)=1/m$ for every $e\in E(H)$. Because every variable $v_{S}$ of $\mathbf{I}_{\omega}$ is in the scope of exactly $m$ constraints (i.e. the constraints in $\{\,c_{i}\;{:}\;i\in S\,\}$), $\gamma$ is indeed a fractional edge cover and because $\sum_{e\in E(H)}\gamma(e)=2m(1/m)=2$ it has size exactly $2$. Note that because $\mathsf{fec}(H)\geq\mathsf{fhtw}(H)$, we obtain from Theorem 13 that $jw(\mathbf{I}_{\omega})\leq 2$.

It remains to show that $\mathsf{jw}_{\emph{proj}}(\mathbf{I}_{\omega})\geq\omega$. Consider an arbitrary join decomposition $\mathcal{J}=(J,\varrho)$ of $\mathbf{I}_{\omega}$. Let $j$ be a node of $J$ such that $\lceil m/2\rceil\leq|L(J_{j})|<m$. Note that such a node $j$ always exists due to the following well-known combinatorial argument.

First we show that there is a node $j^{\prime}$ of $J$ such that $|L(J_{j^{\prime}})|\geq m$ but $|L(J_{j^{\prime\prime}})|<m$ for every child $j^{\prime\prime}$ of $j^{\prime}$ in $J$. Namely, $j^{\prime}$ can be found by going down the tree $J$ starting from the root and choosing a child $j^{\prime\prime}$ of $j^{\prime}$ with $|L(J_{j^{\prime\prime}})|\geq m$, as long as such a child $j^{\prime\prime}$ exists. Then letting $j$ be the child of $j^{\prime}$ maximizing $|L(J_{j})|$ implies that $\lceil m/2\rceil\leq|L(J_{j})|<m$, as required.

We claim that $\mathsf{jw}_{\emph{proj}}(j)\geq\omega$. First note that $S(j)=V(j)$. This is because $|C(\mathbf{I}_{\omega})\setminus X(j)|\geq 2m-(m-1)=m+1$ and hence $\overline{V}(j)=\bigcup_{c\in(C(\mathbf{I}_{\omega})\setminus X(j))}S(c)=V(\mathbf{I}_{\omega})$; this is because $S\cap\{\,i\;{:}\;c_{i}\in C(\mathbf{I}_{\omega})\setminus X(j)\,\}\neq\emptyset$ for every variable $v_{S}$ of $\mathbf{I}_{\omega}$. Consequently, $C_{\emph{proj}}(j)$ is equal to the join of all constraints in $X(j)$. We show next that there are at least $\lceil m/2\rceil$ variables that appear in the scope of exactly one constraint in $X(j)$, which implies that $C_{\emph{proj}}(j)$ contains every of the $n^{\lceil m/2\rceil}$ tuples on these variables. To see this let $O$ be the set of all elements $o\in[2m]$ for which $c_{o}\in X(j)$ and let $\overline{O}$ be the set of all the remaining elements in $[2m]$. Then $|O|\geq\lceil m/2\rceil$ and $|\overline{O}|\geq 2m-(m-1)=m+1$. Let $S^{\prime}$ be any set of exactly $m-1$ elements from $\overline{O}$ and for every $o\in O$, let $S_{o}$ be equal to $\{o\}\cup S^{\prime}$. Then $v_{S_{o}}$ is in the scope of exactly one constraint in $C(j)$ (i.e., the constraint $c_{o}$ and hence there are at least $\lceil m/2\rceil$ variables that occur in the scope of exactly one constraint in $X(j)$, i.e., the variables $\{\,S_{o}\;{:}\;o\in O\,\}$. Hence $C_{\emph{proj}}(j)$ contains at least $n^{\lceil m/2\rceil}$ tuples, which because $\sharp_{\emph{tup}}(\mathbf{I}_{\omega})=n^{2}/2$ implies that $\mathsf{jw}_{\emph{proj}}(j)$ is at least $\lceil m/2\rceil/2\geq m/4\geq\omega$, as required. ∎

5.2 Functionality and Root Sets

Consider a CSP instance $\mathbf{I}=\langle{V,D,C}\rangle$ with $n=|V|$. We say that a constraint $c\in C$ is functional on variable $v\in V$ if $c$ does not contain two tuples that differ only at variable $v$; more formally, for every $t$ and $t^{\prime}\in R(c)$ it holds that if $t[v]\neq t^{\prime}[v]$, then there exists a variable $z\in S(c)$ distinct from $v$ such that $t[z]\neq t^{\prime}[z]$. The instance $\mathbf{I}$ is then called functional if there exists a variable ordering $v_{1}<\dots<v_{n}$ such that, for each $i\in[n]$, there exists a constraint $c\in C$ such that $\pi_{\{v_{1},\dots,v_{i}\}}(c)$ is functional on $v_{i}$. Observe that every CSP instance that is functional can admit at most $1$ solution [5]; this restriction can be relaxed through the notion of root sets, which can be seen as variable sets that form “exceptions” to functionality. Formally, a variable set $Q$ is a root set if there exists a variable ordering $v_{1}<\dots<v_{n}$ such that, for each $i\in[n]$ where $v_{i}\not\in Q$, there exists a constraint $c\in C$ such that $\pi_{\{v_{1},\dots,v_{i}\}}(c)$ is functional on $v_{i}$; we say that $Q$ is witnessed by the variable order $v_{1}<\dots<v_{n}$.

Functionality and root sets were studied for Boolean CSP [10, 9]. Cohen et al. [5] later extended these notions to the CSP with larger domains. Our aim in this section is twofold:

• •

generalize root sets through the introduction of constraint root sets;

• •

show that bounded-size constraint root sets (and also root sets) form a special case of bounded joinwidth.

Before we proceed, it will be useful to show that one can always assume the root set to occur at the beginning of the variable ordering.

Observation 14

Let $Q$ be a root set in $\mathbf{I}$ witnessed by a variable order $\alpha$, assume a fixed arbitrary ordering on $Q$, and let the set $V^{\prime}=V(\mathbf{I})\setminus Q$ be ordered based on the placement of its variables in $\alpha$. Then $Q$ is also witnessed by the variable order $\alpha^{\prime}=Q\circ V^{\prime}$.

Proof

We need to show that $Q$ is a root set witnessed by $\alpha^{\prime}=v_{1}<\dots<v_{|V|}$, i.e., that for each $i$ in $k<i\leq|V|$ there exists a constraint $c\in C$ such that $\pi_{\{v_{1},\dots,v_{i}\}}(c)$ is functional on $v_{i}$. Consider an arbitrary such variable $v_{i}$, and recall that since $Q$ is witnessed by $\alpha$, there must exist a constraint $c$ such that $c^{\prime}=\pi_{Q_{i}\cup V_{i}}(c)$ is functional on $v_{i}$, where $V^{\prime}_{i}$ and $Q_{i}$ are, respectively, the elements of $Q$ and $V^{\prime}$ which occur before $v_{i}$ in $\alpha$. Now, observe that the constraint $c^{*}=\pi_{Q\cup V_{i}}(c)=\pi_{\{v_{1},\dots,v_{i}\}}(c)$ must also be functional on $v_{i}$—indeed, for each pair of tuples $t,t^{\prime}$ in $R(c^{*})$, either $t[v_{i}]=t^{\prime}[v_{i}]$, or $t[v_{i}]\neq t^{\prime}[v_{i}]$ and there exists a variable $z\in Q_{i}\cup V_{i}$ (and hence also in the scope of $c^{*}$) such that $t[z]\neq t^{\prime}[z]$. ∎

For ease of presentation, we will say that $\mathbf{I}$ is $k$-rooted if $k$ is the minimum integer such that $\mathbf{I}$ has a root set of size $k$. It is easy to see, and also follows from the work of David [9] and Cohen et al. [5], that for every fixed $k$ the class of $k$-rooted CSP instances is polynomial-time solvable: generally speaking, one can first loop through and test all variable-subsets of size at most $k$ to find a root $Q$, and then loop through all assignments $Q\rightarrow D$ to get a set of functional CSP instances, each of which can be solved separately in linear time.

While even $1$-rooted CSP instance can have unbounded fractional hypertree width (see also the discussion of Cohen et al. [5]), the class of $k$-rooted CSP instances for a fixed value $k$ is, in some sense, not very robust. Indeed, consider the CSP instance $\mathcal{W}=\langle{\{v_{1},\dots,v_{n}\},\{0,1\},\{c\}}\rangle$ where $c$ ensures that precisely a single variable is set to $1$ (i.e., its relation can be seen as an $n\times n$ identity matrix). In spite of its triviality, it is easy to verify that $\mathcal{W}$ is not $k$-rooted for any $k<n-2$.

Let us now consider the following alternative to measuring the size of root sets in a CSP instance $\mathbf{I}$. A constraint set $P$ is a constraint-root set if $\bigcup_{c\in P}S(c)$ is a root set, and $\mathbf{I}$ is then called $k$-constraint-rooted if $k$ is the minimum integer such that $\mathbf{I}$ has a constraint-root set of size $k$. Since we can assume that each variable occurs in at least one constraint, every $k$-rooted CSP also has a constraint-root set of size at most $k$; on the other hand, the aforementioned example of $\mathcal{W}$ shows that an instance can be $1$-constraint-rooted while not being $k$-rooted for any small $k$. The following result, which we prove by using join decompositions and joinwidth, thus gives rise to strictly larger tractable classes than those obtained via root sets:

Proposition 15

For every fixed $k\in\mathbb{N}$, every $k$-constraint-rooted CSP instance has joinwidth at most $k$ and can be solved in time $|\mathbf{I}|^{\mathcal{O}(k)}$.

Proof

Consider a CSP instance $\mathbf{I}$ with a constraint-root set $P$ of size $k$. We argue that $\mathbf{I}$ has a linear join decomposition of width at most $k$ where the elements of $P$ occur as the leaves farthest from the root. Indeed, consider the linear join decomposition $(J,\varrho)$ constructed in a bottom-up manner, as follows. First, we start by gradually adding the constraints in $P$ as the initial leaves. At each step after that, consider a node $j$ which is the top-most constructed node in the join decomposition. By definition, there must exist a variable $v$ and a constraint $c$ such that $\pi_{\bigcup_{c\in P}S(c)}(c)$ is functional on $v$. Moreover, this implies that $|\pi_{\bigcup_{c\in P}S(c)}(c)\Join C(j)|\leq|C(j)|$, and thus $|c\Join C(j)|\leq|C(j)|$. Hence this procedure does not increase the size of constraints at nodes after the initial $k$ constraints, immediately resulting in the desired bound of $k$ on the width of $(J,\varrho)$.

To complete the proof, observe that a join decomposition with the properties outlined above can be found in time at most $|\mathbf{I}|^{\mathcal{O}(k)}$: indeed, it suffices to branch over all $k$-element subsets of $C(\mathbf{I})$ and test whether the union of their scopes is functional using, e.g., the result of Cohen et al. [5, Corollary 1]. Once we have such a join decomposition, we can solve the instance by invoking Theorem 6. ∎

As a final remark, we note that the class of $k$-constraint rooted CSP instances naturally includes all instances which contain $k$ constraints that are in conflict (i.e., which cannot all be satisfied at the same time).

5.3 Other Tractable Classes

Here, we identify some other classes of tractable CSP instances with bounded joinwidth. First of all, we consider CSP instances such that introducing their variables in an arbitrary order always results in a subinstance with polynomially many solutions. In particular, we call a CSP instance $\mathbf{I}$ hereditarily $k$-bounded if for every subset $V^{\prime}$ of its variables it holds that $|\textup{SOL}(\mathbf{I}[V^{\prime}])|\leq\sharp_{\emph{tup}}(\mathbf{I})^{k}$. Examples of hereditarily $k$-bounded CSP instances include $k$-Turan CSPs [5, page 12] and CSP instances with fractional edge covers of weight $k$ [22].

Proposition 16

The class of hereditarily $k$-bounded CSP instances has joinwidth at most $k$ and can be solved in time at most $\mathcal{O}(|\mathbf{I}|^{k})$.

Proof

Consider an arbitrary linear join decomposition $(J,\varrho)$. By definition, for each $j\in V(J)$, $|\textup{SOL}(\mathbf{I}[V(j)])|\leq\sharp_{\emph{tup}}(\mathbf{I})^{k}$. Then $|\pi_{\overline{V}(j)}(\textup{SOL}(\mathbf{I}[V(j)]))|$ $\leq\sharp_{\emph{tup}}(\mathbf{I})^{k}$, and by Lemma 5 we obtain $|C(j)|\leq\sharp_{\emph{tup}}(\mathbf{I})^{k}$, as required. ∎

Another example of a tractable class of CSP instances that we can solve using joinwidth are instances where all constraints interact in a way which forces a unique assignment of the variables. In particular, we say that a CSP $\mathbf{I}=\langle{V,D,C}\rangle$ is unique at depth $k$ if for each constraint $c\in C$ there exists a fixing set $C^{\prime}\subseteq C$ such that $c\in C^{\prime}$, $|C^{\prime}|\leq k$, and $|(\Join_{c^{\prime}\in C^{\prime}}c^{\prime})|\leq 1$.

Proposition 17

The class of CSP instances which are unique at depth $k$ has joinwidth at most $k$ and can be solved in time at most $|\mathbf{I}|^{\mathcal{O}(k)}$.

Proof

First of all, we observe that it is possible to determine whether a CSP instance $\mathbf{I}$ is unique at depth $k$ in time at most $|\mathbf{I}|^{\mathcal{O}(k)}$. Indeed, it suffices to check whether each constraint $c$ is contained in at least one fixing set—and to do that, we can simply loop over all constraint sets of arity at most $k$ and join them together (in an arbitrary order). If $\mathbf{I}$ contains a constraint that does not appear in any fixing set of size at most $k$, then it is not unique at depth $k$; otherwise, for each constraint $c$ we choose an arbitrary fixing set (containing $c$) and denote it as $\mathsf{Fix}(c)$.

Consider a linear join decomposition $\mathcal{J}$ constructed as follows. First, we choose an arbitrary ordering of the constraints and denote these $c_{1}<\dots<c_{m}$. We begin our construction by having $\mathcal{J}$ introduce the constraints which occur in $\mathsf{Fix}(c_{1})$ (in an arbitrary order). Then, for each $2\leq i\leq m$, we introduce those constraints in $\mathsf{Fix}(c_{i})$ which are not yet introduced in $\mathcal{J}$ (also in an arbitrary order).

It remains to argue that $\mathcal{J}$ has joinwidth at most $k$. Consider the node $j_{1}$ whose child is the last constraint occurring in $\mathsf{Fix}(c_{1})$ (i.e., all constraints in $\mathsf{Fix}(c_{1})$ occur as leaves which are descendants of $j_{1}$, and all constraints not in $\mathsf{Fix}(c_{1})$ occur as leaves which are not descendants of $j_{1}$). By definition, $|\Join_{c^{\prime}\in\mathsf{Fix}(c_{1})}c^{\prime}|\leq 1$ and hence by Lemma 5 we obtain $|C(j_{1})|\leq 1$. Moreover, since there are at most $k$ leaves below $j_{1}$, for each descendant $j_{1}^{\prime}$ of $j_{1}$ we obtain that $|C(j_{1}^{\prime})|<(\sharp_{\emph{tup}}(\mathbf{I}))^{k}$, as required. Now, consider an arbitrary $2\leq i\leq m$, and as before let $j_{i}$ be the node whose child is the last constraint occurring in $\mathsf{Fix}(c_{i})$. Once again, $|C(j_{i})|\leq 1$ by definition. Moreover, since there are at most $k$ leaves which occur “between” $j_{i}$ and $j_{i-1}$, $\mathcal{J}$ contains at most $k-1$ non-leaf nodes between $j_{i}$ and $j_{i-1}$. Since $|C(j_{i-1})|\leq 1$, it follows that every node $j_{i}^{\prime}$ between $j_{i}$ and $j_{i-1}$ also has $|C(j_{1}^{\prime})|<(\sharp_{\emph{tup}}(\mathbf{I}))^{k}$. Hence $\mathcal{J}$ indeed has joinwidth at most $k$, and the proposition follows by Theorem 6. ∎

6 Solving Bounded-Width Instances

This section investigates the tractability of CSP instances whose joinwidth is bounded by a fixed constant $\omega$. In particular, one can investigate two notions of tractability. The first one is the classical notion of polynomial-time tractability, which asks for an algorithm of the form $|\mathbf{I}|^{\mathcal{O}(1)}$. In this setting, the complexity of CSP instances of bounded joinwidth remains an important open problem. Note that the NP-hardness of the $\omega$-Join Decomposition problem established in Theorem 7 does not exclude polynomial-time tractability for CSP instances of bounded joinwidth. For instance, tractability could still be obtained with a suitable approximation algorithm for computing join decompositions (as it is the case for fractional hypertreewidth [27]) or by using an algorithm that does not require a join decomposition of bounded width as input.

The second notion of tractability we consider is called fixed-parameter tractability and asks for an algorithm of the form $f(k)\cdot|\mathbf{I}|^{\mathcal{O}(1)}$, where $k$ is a numerical parameter capturing a certain natural measure of $\mathbf{I}$. Prominently, Marx investigated the fixed-parameter tractability of CSP and showed that CSP instances whose hypergraphs have bounded submodular width [29] are fixed-parameter tractable when $k$ is the number of variables. Moreover, Marx showed that submodular width is the most general structural property among those measured purely on hypergraphs with this property.

Here, we obtain two single-exponential fixed-parameter algorithms for CSP instances of bounded joinwidth (i.e., algorithms with a running time of $2^{\mathcal{O}(k)}\cdot|\mathbf{I}|^{\mathcal{O}(1)}$): one where $k$ is the number of variables, and the other where $k$ is the number of constraints. Since there exist classes of instances of bounded joinwidth and unbounded submodular width (see Observation 12), this expands the frontiers of (fixed-parameter) tractability for CSP.

Parameterization by Number of Constraints.

To solve the case where $k$ is the number of constraints, our primary aim is to obtain a join decomposition of width at most $\omega$, i.e., solve the $\omega$-Join Decomposition problem defined in Section 3. Indeed, once that is done we can solve the instance by Theorem 6.

Theorem 18

$\omega$-Join Decomposition can be solved in time $\mathcal{O}(4^{|C|}+2^{|C|}|\mathbf{I}|^{2\omega+1})$ and is hence fixed-parameter tractable parameterized by $|C|$, for a CSP instance $\mathbf{I}=\langle{V,D,C}\rangle$.

Proof

Let $\mathbf{I}=\langle{V,D,C}\rangle$ be the given CSP instance. For a subset $C^{\prime}\subseteq C$, we denote by $S(C^{\prime})$ the set of all variables that are both in the scope of a constraint in $C^{\prime}$ and in the scope of a constraint in $C\setminus C^{\prime}$. The algorithm uses dynamic programming to compute the mapping $\alpha$ that for every non-empty subset $C^{\prime}$ of $C$ either:

• •

is equal to $\pi_{S(C^{\prime})}(\textup{SOL}(\mathbf{I}[V(C^{\prime})]))$, if there is a partial join decomposition for $\mathbf{I}$ that covers the constraints in $C^{\prime}$ of width at most $\omega$, and

• •

otherwise is equal to $\infty$.

Note that $\mathbf{I}$ has a join decomposition of width at most $\omega$ if and only if $\alpha(C)\neq\infty$.

To compute $\alpha$ we use the observation that a partial join decomposition covering a set $C^{\prime}$ of constraints is either a leaf (if $|C^{\prime}|=1$) or is obtained as the “join” of a partial join decomposition covering $C_{0}$ and a partial join decomposition covering $C^{\prime}\setminus C_{0}$ for some non-empty $C_{0}\subset C^{\prime}$. This immediately implies that $\alpha$ satisfies the following recurrence relation for every non-empty subset $C^{\prime}$ of $C$:

• (R1)

if $C^{\prime}=\{c\}$ for some $c\in C$, then $\alpha(C^{\prime})=\textsf{prune}(\pi_{S(C^{\prime})}(c))$,

• (R2)

if $|C^{\prime}|>1$ and there is a non-empty subset $C_{0}\subset C^{\prime}$ such that:

• (C1)

$\alpha(C_{0})\neq\infty$ and $\alpha(C^{\prime}\setminus C_{0})\neq\infty$, and

• (C2)

$|\textsf{prune}((\pi_{S(C^{\prime})}(\alpha(C_{0})\Join\alpha(C^{\prime}\setminus C_{0}))))|\leq\sharp_{\emph{tup}}(\mathbf{I})^{\omega}$,

then $\alpha(C^{\prime})=\textsf{prune}(\pi_{S(C^{\prime})}((\alpha(C_{0})\Join\alpha(C\setminus C_{0}))))$,

• (R3)

otherwise, i.e., if $|C^{\prime}|>1$ and (R2) does not apply, then $\alpha(C^{\prime})=\infty$.

Since $\mathbf{I}$ has a join decomposition of width at most $\omega$ if and only if $\alpha(C)\neq\infty$ and in this case a join decomposition for $\mathbf{I}$ can be easily constructed by following the recurrence relation starting from $\alpha(C)$, it only remains to show how to compute $\alpha$ in the required running time, which we do as follows.

Initially, we set $\alpha(\{c\})=\textsf{prune}(\pi_{S(C^{\prime})}(c))$ for every $c\in C$ and $\alpha(C^{\prime})=\infty$ for every $C^{\prime}$ with $\emptyset\neq C^{\prime}\subseteq C$ and $|C^{\prime}|>1$. We then enumerate all subsets $C^{\prime}$ with $C^{\prime}\subseteq C$ and $|C^{\prime}|>1$ in order of increasing size and check whether there is a subset $C_{0}$ of $C^{\prime}$ satisfying the conditions stated in (R2). If so we set $\alpha(C^{\prime})=\textsf{prune}((\pi_{S(C^{\prime})}(\alpha(C_{0})\Join\alpha(C\setminus C_{0}))))$ and otherwise we set $\alpha(C^{\prime})=\infty$. Clearly, the time required to initialize $\alpha$ is at most $\mathcal{O}(2^{|C|}+|\mathbf{I}|)$. Furthermore, the time required to check, whether a subset $C^{\prime}$ satisfies the conditions stated in (R2) is at most $\mathcal{O}(2^{|C^{\prime}|}+|\mathbf{I}|^{2\omega+1})=\mathcal{O}(2^{|C|}+|\mathbf{I}|^{2\omega+1})$, which can be obtained as follows. First note that because of Lemma 5, it holds that $\textsf{prune}(\pi_{S(C^{\prime})}((\alpha(C_{0})\Join\alpha(C^{\prime}\setminus C_{0}))))$ is equal to $\textsf{prune}((\pi_{S(C^{\prime})}(\alpha(C_{0}^{\prime})\Join\alpha(C^{\prime}\setminus C_{0}^{\prime}))))$ for any two subsets $C_{0}$ and $C_{0}^{\prime}$ satisfying (C1) and hence once we found a subset $C_{0}$ satisfying (C1) and have computed $\textsf{prune}((\pi_{S(C^{\prime})}(\alpha(C_{0})\Join\alpha(C^{\prime}\setminus C_{0}))))$, we can determine whether (R2) or (R3) applies for $C^{\prime}$. This implies that we have to compute $\textsf{prune}((\pi_{S(C^{\prime})}(\alpha(C_{0})\Join\alpha(C^{\prime}\setminus C_{0}))))$ for at most one subset $C_{0}$, which explains why $|\mathbf{I}|^{2\omega+1}$ only appears additively in the running time. Moreover, the term $2^{|C|}$ is required for the enumeration of all subsets $C_{0}$ of $C^{\prime}$. Since we have to enumerate all subsets $C^{\prime}$ of $C$, we hence obtain $\mathcal{O}(2^{|C|}(2^{|C|}+|\mathbf{I}|^{2\omega+1}))=\mathcal{O}(4^{|C|}+2^{|C|}|\mathbf{I}|^{2\omega+1})$ as the total running time for computing $\alpha$. ∎

From Theorem 18 and Theorem 6 we immediately obtain:

Corollary 19

*A CSP instance $\mathbf{I}$ with $k$ constraints and joinwidth at most $\omega$ can be solved in time $2^{\mathcal{O}(k)}\cdot|\mathbf{I}|^{\mathcal{O}(\omega)}$. *

Parameterization by Number of Variables.

Note that Corollary 19 immediately establishes fixed-parameter tractability for the problem when $k$ is the number of variables (instead of the number of constraints), because one can assume that $|C|\leq 2^{|V|}$ for every CSP instance $\mathbf{I}=(V,D,C)$. However, the resulting algorithm would be double-exponential in $|V|$. The following theorem shows that this can be avoided by designing a dedicated algorithm for CSP parameterized by the number of variables. The main idea behind both algorithms is dynamic programming, however, in contrast to the algorithm for $|C|$, the table entries for the fpt-algorithm for $|V|$ correspond to subsets of $V$ instead of subsets of $C$. Interestingly, the fpt-algorithm for $|V|$ does not explicitly construct a join decomposition, but only implicitly relies on the existence of one.

Theorem 20

*A CSP instance $\mathbf{I}$ with $k$ variables and joinwidth at most $\omega$ can be solved in time $2^{\mathcal{O}(k)}\cdot|\mathbf{I}|^{\mathcal{O}(\omega)}$. *

Proof

Let $\mathbf{I}=\langle{V,D,C}\rangle$ be the given CSP instance with $\mathsf{jw}(\mathbf{I})\leq\omega$. For a subset $V^{\prime}\subseteq V$, we denote by $S(V^{\prime})$ the set of variables in $V^{\prime}\cap\{\,v\;{:}\;c\in C\land S(c)\setminus V^{\prime}\neq\emptyset\land v\in S(c)\,\}$ (i.e., $S(V^{\prime})$ contains variables in $V^{\prime}$ which occur in the scope of a constraint that also has variables outside of $V^{\prime}$). The algorithm uses dynamic programming to compute a mapping $\alpha$ which maps non-empty subsets $V^{\prime}$ of $V$ to either the constraint $\pi_{S(V^{\prime})}(\textup{SOL}(\mathbf{I}[V^{\prime}]))$, or to $\infty$. $\alpha$ is defined using the following recurrence:

• (R1)

if $V^{\prime}=S(c)$ for some $c\in C$, then $\alpha(V^{\prime})=\textsf{prune}(\pi_{S(V^{\prime})}(c))$,

• (R2)

if (R1) does not apply and there are subsets $V_{0}$ and $V_{1}$ with $\emptyset\neq V_{0},V_{1}\subset V^{\prime}$ and $V_{0}\cup V_{1}=V^{\prime}$ such that:

• (C1)

$\alpha(V_{0})\neq\infty$ and $\alpha(V_{1})\neq\infty$, and

• (C2)

$|\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))|\leq\sharp_{\emph{tup}}(\mathbf{I})^{\omega}$,

then $\alpha(V^{\prime})=\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))$,

• (R3)

otherwise, i.e., if neither (R1) nor (R2) applies, then $\alpha(V^{\prime})=\infty$.

Using arguments very similar to the ones used in the proof of Lemma 5 it is now easy to show that if $\alpha(V^{\prime})\neq\infty$, then $\alpha(V^{\prime})=\pi_{S(V^{\prime})}(\textup{SOL}(\mathbf{I}[V^{\prime}]))$ for every subset $V^{\prime}\subseteq V$.

It follows that if $\alpha(V)\neq\infty$, then $\mathbf{I}$ has a solution if and only if $\alpha(V)$ is not equal to the empty constraint. Hence an algorithm that computes $\alpha$ can be used to solve every CSP instance for which $\alpha(V)\neq\infty$. In order to show that we can solve a CSP instance $\mathbf{I}$ of joinwidth at most $\omega$, it is hence sufficient to show that $\alpha(V)\neq\infty$.

To this end, consider a join decomposition $\mathcal{J}=(J,\varrho)$ for $\mathbf{I}$ of width at most $\omega$. Using a bottom-up induction on $J$, we will show that $\alpha(V(j))\neq\infty$ and moreover $C(j)=\alpha(V(j))$ for every $j\in V(j)$. Since $\alpha(V)=C(r)\neq\infty$ for the root $r$ of $J$, this then implies the desired property. $C(j)=\alpha(V(j))$ clearly holds for every leaf $l$ of $J$, because $V(l)$ satisfies (R1) and by Lemma 5 we have $C(l)=\pi_{S(l)}(\textup{SOL}(\mathbf{I}[V(l)]))=\pi_{S(V(l))}(\textup{SOL}(\mathbf{I}[V(l)]))$. Now, consider an inner node $j$ of $J$ with children $j_{1}$ and $j_{2}$. Then setting $V^{\prime}$ to $V(j)$, $V_{0}$ to $V(j_{1})$, and $V_{1}$ to $V(j_{2})$ satisfies (C1) (of (R2)) because of the induction hypothesis. Moreover, (C2) is also satisfied because $\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))=\pi_{S(V^{\prime})}(\textup{SOL}(\mathbf{I}[V^{\prime}]))=\pi_{S(j)}(\textup{SOL}(\mathbf{I}[V(j)]))=C(j)$ and $|C(j)|\leq\sharp_{\emph{tup}}(\mathbf{I})^{\omega}$. Hence an algorithm that computes $\alpha$ can be used to solve every CSP instance of bounded joinwidth, and it only remains to show how to compute $\alpha$.

Initially, we set $\alpha(V^{\prime})=\textsf{prune}(c)$ for every $V^{\prime}\subseteq V$ such that there is constraint $c\in C$ with $V^{\prime}=S(c)$ and $\alpha(V^{\prime})=\infty$ for every $V^{\prime}\subseteq V$ for which this is not the case. We then enumerate all subsets $V^{\prime}$ with $\emptyset\neq V^{\prime}\subseteq V$ in order of increasing sizes and if $\alpha(V^{\prime})=\infty$, we check whether there are subsets $V_{0}$ and $V_{1}$ of $V^{\prime}$ satisfying the conditions stated in (R2). If so we set $\alpha(V^{\prime})=\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))$ and otherwise we set $\alpha(V^{\prime})=\infty$. Clearly, the time required to initialize $\alpha$ is at most $\mathcal{O}(2^{|V|}+|C|)$. Furthermore, the time required to check whether a subset $V^{\prime}$ satisfies the conditions stated in (R2) is at most $\mathcal{O}(2^{|V|}2^{|V|}+|\mathbf{I}|^{2\omega+1})=\mathcal{O}(4^{|V|}+|\mathbf{I}|^{2\omega+1})$—indeed, this can be carried out as follows. To begin, we observe that $\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))$ is equal to $\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0}^{\prime})\Join\alpha(V_{1}^{\prime})))$ for any two pairs $(V_{0},V_{1})$ and $(V_{0}^{\prime},V_{1}^{\prime})$ of subsets satisfying (C1), and hence after we find a pair $(V_{0},V_{1})$ of subsets satisfying (C1) and compute $\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))$, we can determine whether (R2) or (R3) applies for $V^{\prime}$. This implies that we have to compute $\textsf{prune}(\pi_{S(V^{\prime})}(\alpha(V_{0})\Join\alpha(V_{1})))$ for at most one pair $(V_{0},V_{1})$ of subsets, which explains why $|\mathbf{I}|^{2\omega+1}$ only appears additively in the running time. Moreover, the term $4^{|V|}$ is required for the enumeration of all pairs $(V_{0},V_{1})$ for $V^{\prime}$. Since we have to enumerate all subsets $V^{\prime}$ of $V$, we obtain $\mathcal{O}(2^{|V|}(4^{|V|}+|\mathbf{I}|^{2\omega+1}))=\mathcal{O}(6^{|V|}+2^{|V|}|\mathbf{I}|^{2\omega+1})$, as the total running time for computing $\alpha$. ∎

7 Beyond Join Decompositions

Due to their natural and “mathematically clean” definition, one might be tempted to think that join decompositions capture all the algorithmic power offered by join and projection operations. It turns out that this is not the case, i.e., we show that if one is allowed to use join and projections in an arbitrary manner (instead of the more natural but also more restrictive way in which they are used within join decompositions) one can solve CSP instances that are out-of-reach even for join decompositions. This is interesting as it points towards the possibility of potentially more powerful parameters based on join and projections than joinwidth.

Theorem 21

For every $\omega$, there exists a CSP instance $\mathbf{I}_{\omega}$ that can be solved in time $\mathcal{O}(|\mathbf{I}|^{4})$ using only join and projection operations but $\mathsf{jw}(\mathbf{I}_{\omega})\geq\omega$.

Proof

Let $n=\omega*16$ and let $\mathbf{I}_{\omega}=\langle{V,D,C}\rangle$ be the CSP instance with variables $x_{1},\dotsc,x_{n}$, domain $\{1,\dotsc,n\}$, and the following constraints:

• •

A set $C_{<}=\{\,c_{1},\dotsc,c_{n-1}\,\}$ of binary constraints $c_{i}$ with scope $(x_{i},x_{i+1})$ containing all tuples $t\in n\times n$ such that $t[x_{i}]<t[x_{i+1}]$,

• •

A set $C_{C}=\{\,c_{l,m}\;{:}\;l<m-1\land 1\leq l,m\leq n\,\}$ of binary and complete constraints $c_{l,m}$ with scope $(x_{l},x_{m})$.

We start by showing that $\mathsf{jw}(\mathbf{I}_{\omega})\geq\omega$. Let $(J,\varrho)$ be any join decomposition for $\mathbf{I}_{\omega}$. Let $j$ be a node of $J$ such that $\lceil 1/4n\rceil\leq|V(j)|\leq\lfloor 1/2n\rfloor$, which exists due to the following well-known argument.

First we show that there is a node $j^{\prime}$ of $J$ such that $|V(j^{\prime})|\geq\lfloor 1/2n\rfloor$ but $|V(j^{\prime\prime})|\leq\lfloor 1/2n\rfloor$ for every child $j^{\prime\prime}$ of $j^{\prime}$ in $J$. Namely, $j^{\prime}$ can be found by going down the tree $J$ starting from the root and choosing a child $j^{\prime\prime}$ of $j^{\prime}$ with $|V(j^{\prime\prime})|\geq\lfloor 1/2n\rfloor$; as long as such a child $j^{\prime\prime}$ exists. Then letting $j$ be the child of $j^{\prime}$ maximizing $|V(j)|$ implies that $\lceil 1/4n\rceil\leq|V(j)|\leq\lfloor 1/2n\rfloor$, as required.

Note that because $\mathbf{I}_{\omega}$ has a constraint with scope $(x_{l},x_{m})$ for every $l<m$, it holds that $\overline{V}(j)=V$ for the node $j\in V(J)$; this is because there is at least one variable in $V\setminus V(j)$ and this variable occurs in a binary constraint with every other variable. Hence by Lemma 5, it holds that $C(j)=\textup{SOL}(\mathbf{I}_{\omega}[V(j)])$.

We claim that $C(j)$ contains at least $(n/2)^{n/4}$ tuples. Towards showing the claim, let $\mathbf{I}_{\omega}(i)$ be any sub-instance of $\mathbf{I}_{\omega}$ induced by any subset of $V$ of size $i$. It is easy to see that the domain of any variable in $\mathbf{I}_{\omega}(i)$ has size at least $n-i$ and hence $\textup{SOL}(\mathbf{I}_{\omega})$ has at least $(n-i)^{i}$ tuples. Hence, because $\lceil 1/4n\rceil|V(j)|\leq\lfloor 1/2n\rfloor$, we obtain that $C(j)$ has at least $\min\{(3/4n)^{1/4n},(1/2n)^{1/2n}\}\geq(n/2)^{n/4}$ tuples, as required.

Finally, since $\sharp_{\emph{tup}}(\mathbf{I}_{\omega})=n^{2}$, we obtain the following for the joinwidth of $\mathbf{I}_{\omega}$.

[TABLE]

The inequality in the above sequence follows since $n^{2}\geq 16^{2}=4^{4}$.

It remains to show that we can solve $\mathbf{I}_{\omega}$ in time $\mathcal{O}(|\mathbf{I}_{\omega}|^{4})$ using only join and projection operations.

Towards showing this we now define various auxiliary constraints that can be obtained efficiently using only join and projection operations from the constraints in $C$.

Namely, for every $i$ with $1<i\leq n$ let $b_{i}^{\uparrow}$ be the constraint defined iteratively as follows. Set $b_{2}^{\uparrow}$ to be the constraint $\pi_{\{x_{2}\}}(c_{1})$ and for every $i>2$, set $b_{i}^{\uparrow}$ to be the constraint $\pi_{\{x_{i}\}}(b_{i-1}^{\uparrow}\Join c_{i-1})$. Note that $S(b_{i}^{\uparrow})=\{x_{i}\}$ and $R(b_{i}^{\uparrow})$ contains all tuples $t$ with $t[x_{i}]\in\{i,\dotsc,n\}$. Moreover, it follows immediately from their defintion that the constraints $b_{2}^{\uparrow},\dotsc,b_{n}^{\uparrow}$ can be computed in time at most $\mathcal{O}(n^{4})=\mathcal{O}(|\mathbf{I}_{\omega}|^{4})$ using only join and projection operations.

Similarily, let $b_{i}^{\downarrow}$ for every $i$ with $1\leq i<n$ be the constraint defined recursively as follows. Let $b_{n-1}^{\downarrow}$ be the constraint $\pi_{\{x_{n-1}\}}(c_{n-1})$ and for every $i<n-1$, we set $b_{i}^{\downarrow}$ to be the constraint $\pi_{\{x_{i}\}}(b_{i+1}^{\downarrow}\Join c_{i})$. Note that $S(b_{i}^{\downarrow})=\{x_{i}\}$ and $R(b_{i}^{\downarrow})$ contains all tuples $t$ with $t[x_{i}]\in\{1,\dotsc,i\}$. Moreover, it follows immediately from their definition that the constraints $b_{1}^{\downarrow},\dotsc,b_{n-1}^{\downarrow}$ can be computed in time at most $\mathcal{O}(n^{4})=\mathcal{O}(|\mathbf{I}_{\omega}|^{4})$ using only join and projection operations.

Note that $b_{i}^{\uparrow}\Join b_{i}^{\downarrow}$ for every $i$ with $1<i<n$ has scope $\{x_{i}\}$ and contains only one tuple, i.e., the tuples $t$ with $t[x_{i}]=i$. Moreover, $b_{1}^{\downarrow}$ and $b_{n}^{\uparrow}$ also contain only one tuple, i.e., the tuples $t$ with $t[x_{1}]=1$ and $t[x_{n}]=n$, respectively. To use this observation let $b_{1}$ be the constraint $b_{1}^{\downarrow}$, $b_{n}$ be the constraint $b_{n}^{\uparrow}$ and for every $i$ with $1<i<n$ let $b_{i}$ be the constraint $b_{i}^{\uparrow}\Join b_{i}^{\downarrow}$. Then $b_{i}$ has scope $\{x_{i}\}$ and $R(b_{i})$ contains only one tuple, i.e., the tuple $t$ with $t[x_{i}]=i$. Moreover, it follows immediately from the definition of the constraints $b_{1},\dotsc,b_{n}$ that they can be computed from the constraints $b_{i}^{\uparrow},b_{i}^{\downarrow}$ in time at most $\mathcal{O}(n^{2})=\mathcal{O}(|\mathbf{I}_{\omega}|^{2})$ using only join operations.

Note that at this stage, we have already identified the unique solution of $\mathbf{I}_{\omega}$; the one that sets every variable $x_{i}$ to the value $i$. However, since we have not yet even considered all constraints of $\mathbf{I}_{\omega}$, we cannot yet bet sure that what we computed is actually a solution of $\mathbf{I}$. To circumvent this caveat, we now compute the constraint $b=b_{1}\Join\dotsb\Join b_{n}$ in time $\mathcal{O}(n)$; note that $b$ has scope $V$ and $R(b)$ only contains the tuple $t$ with $t[x_{i}]=i$ for every $i$ with $1\leq i\leq n$. Finally, we join every constraint $c\in C$ with $b$ one-by-one as follows. Assume that $C=\{c^{1},\dotsc,c^{|C|}\}$. Then for every $i$ with $1\leq i\leq|C|$, we now compute the constraint $a_{i}$ iteratively by setting: $a_{1}$ to be the constraint $b\Join c^{1}$ and for every $i>1$, $a_{i}$ is the contraint $a_{i-1}\Join c^{i}$. Now we can be sure that the constraint $a_{|C|}$ contains all solutions (and only the solutions) of $\mathbf{I}$. Since $a_{i}$ is equal to $b$ for every $i$ it also follows that we can compute the constraints $a_{1},\dotsc,a_{|C|}$ in time $\mathcal{O}(|C|)=\mathcal{O}(|\mathbf{I}_{\omega}|)$ using only join operations. ∎

8 Conclusions and Outlook

The main contribution of our paper is the introduction of the notion of a join decomposition and the associated parameter joinwidth (Definitions 2 and 3). These notions are natural as they are entirely based on fundamental operations of relational algebra: joins, projections, and pruning (which can equivalently be stated in terms of semijoins). It is also worth noting that our algorithms seamlessly extend to settings where each variable has its own domain (this can be modeled, e.g., by unary constraints).

We establish several structural and complexity results that put our new notions into context. In particular, we show that:

bounded joinwidth captures and properly contains several known restrictions that render CSP tractable (Theorem 13, Propositions 15, 16 and 17). 2. 2.

CSP instances of bounded joinwidth can be solved in polynomial time assuming the corresponding join decomposition is provided with the input (Theorem 6); 3. 3.

finding a join decomposition of optimal width is NP-hard, already for a constant upper bound on the width (Theorem 7), mirroring the situation surrounding fractional hypertree width [15]; 4. 4.

CSP instances of bounded joinwidth can be solved by a single-exponential fixed-parameter algorithm parameterized either by the number of constraints (Corollary 19) or the number of variables (Theorem 20); 5. 5.

there are instances of bounded joinwidth but unbounded submodular (or adaptive) width (Observation 12); bounded submodular width is the most general hypergraph restriction that allows for fixed-parameter tractability of CSP under the Exponential Time Hypothesis [29]; 6. 6.

using joins and projections, one can even solve instances of unbounded joinwidth (Theorem 21).

Our results give rise to several interesting directions for future work. We believe that result (2) can be generalized to other problems, such as #CSP or the FAQ-Problem [25]. Result (3) gives rise to the question of whether there exists a polynomial-time approximation algorithm for computing join decompositions of suboptimal joinwidth, similar to Marx’s algorithm for fractional hypertree-width [27]. One can also try to develop an efficient heuristic approach for computing the exact joinwidth, possibly similar to the SMT-encoding for fractional hypertree width as recently proposed by Fichte et al. [14].

Result (5) shows that submodular width is not more general than joinwidth. We conjecture that also the converse direction holds, i.e., that the two parameters are actually incomparable. Motivated by result (6), one could try to define a natural parameter that captures the full generality of join and projection operations, or to at least define a parameter that is more general than join decompositions without sacrificing the simplicity of the definition.