When Does Sparsity Help for $k$-Independent Set in Hypergraphs and Other Boolean CSPs?

Without taking sparsity into account, previous works [22, 20] establish the following regimes within the Boolean constraint families: (1) problems fine-grained equivalent to ${\text{Csp}}_k(\text{NAND})$, (2) problems fine-grained equivalent to ${\text{Csp}}_k(\text{IMPL})$ where $\text{IMPL}(x,y)=x\to y$, and (3) FPT problems.

For the two central hard CSPs, it is not too difficult to establish the following baselines (see Section 4):

1. 1.

   ${\text{Csp}}_k^{\gamma }(\text{NAND})$, i.e., $k$-IS in graphs, is trivial if and has complexity $O(n^{\omega k/3\pm c})$ if $\gamma =2$, assuming the clique hypothesis.

2. 2.

   ${\text{Csp}}_k^{\gamma }(\text{IMPL})$ is trivial if and has time complexity $n^{g(k)}$ uniformly for all $1\le \gamma \le 2$, where $\mathrm{\Omega }(\sqrt[3]{k})\le g(k)\le O(\sqrt{k})$, assuming the clique hypothesis.

We find that surprisingly, the combined constraint family $\{\text{IMPL},\text{NAND}\}$ has higher time complexity for all than either IMPL or NAND individually.

Thus, for , while ${\text{Csp}}_k^{\gamma }(\text{NAND})$ is trivial and ${\text{Csp}}_k^{\gamma }(\text{IMPL})$ has a subexponential time complexity $n^{g(k)}$, the combination of both constraints has an exponential time complexity that is a natural interpolation of the $k$-IS running time.

The above theorem consists of two parts: (1) a conditional lower bound and (2) a matching algorithm. The conditional lower bound is strikingly simple: We can introduce $\approx n-n_0$ IMPL-constraints enforcing that any satisfying assignment with $k$ nonzeroes chooses its nonzero variables from a set $V_0\subseteq V$ of size $n_0$. On $V_0$, we embed an arbitrary, possibly dense instance as long as $n_0^2=O(m)$. By choosing $n_0\approx \sqrt{m}$, we can reduce from a $k$-clique instance in an $\sqrt{m}$-vertex graph, yielding a conditional lower bound of $m^{k\omega /6-o(1)}$, as desired.

The corresponding upper bound does not follow as easily. To beat time $O(n^{\omega k/3})$ when the input contains only few NAND- and IMPL-constraints, one might hope for a “reversal” of the reduction in the conditional lower bound: is it possible to quickly “peel off” most of the variables so that a small set of $O(\sqrt{m})$ variables survives? Unfortunately, possibly intricate interactions between IMPL- and NAND-constraints prevent simple preprocessing schemes. Instead, we perform a careful combination of arguments: We first preprocess the instance to obtain a structured setting in which crucially each variable implies at most one other variable. We use this structured setting to group the variables, yielding a win-win argument: Either (1) there exists a “large” group with few NAND constraints, and we can detect a solution within this single group greedily, or (2) all groups are “small”. In this case, we carefully reduce to an almost-balanced Triangle Detection instance. For more details, we refer to Section 1.3 and the full proof in Section 4.

Interestingly, we observe that among the binary constraint families, the regime of ${\text{Csp}}_k^{\gamma }(\{\text{NAND},\text{IMPL}\})$ is the only new regime that emerges. Specifically, we arrive at the following classification, illustrated in Figure 1.

We prove the first part in Section 4, deferring details on the remaining parts to the full paper due to space constraints.

Classifying the influence of sparsity for higher-arity constraint families becomes significantly more challenging. Already the question how many constraints are minimally required to define a non-trivial instance is not obvious. We shall however see, that for a large class of constraint families, this quantity is decisive to understand the time complexity, as we observe a phase transition at this triviality cutoff.

Specifically, we say that ${\text{Csp}}_k^{\gamma }(ℱ)$ is non-trivial if there are infinitely many NO instances in ${\text{Csp}}_k^{\gamma }(ℱ)$; conversely, it is trivial, if for all sufficiently large $n$, any instance of ${\text{Csp}}_k^{\gamma }(ℱ)$ with $n$ variables is a YES instance. For any constraint family $ℱ$, we define the triviality cutoff ${\gamma }_{\mathrm{triv}}$ as the smallest $\gamma \ge 0$ such that ${\text{Csp}}_k^{\gamma }(ℱ)$ is non-trivial. Thus, every $n$-variable instance with sufficiently large $n$ and $O(n^{{\gamma }_{\mathrm{triv}}-ϵ})$ constraints from $ℱ$ contains a solution, while there exists infinitely many instances with $\mathrm{\Theta }(n^{{\gamma }_{\mathrm{triv}}})$ constraints from $ℱ$ that do not contain a solution with $k$ nonzeroes.

We first introduce a parameter $u_{\min }(ℱ)$ that describes this triviality cutoff. Specifically, let $u_{\min }(f)$ denote the smallest weight ${\Vert x\Vert }_1$ of an assignment $x$ violating $f$, i.e., $u_{\min }(f)=\min \{{\Vert x\Vert }_1\mid f(x)=0\}$. Defining $u_{\min }(ℱ)≔{\min }_{f\in ℱ}{u}_{\min }(f)$, we can establish the triviality cutoff ${\gamma }_{\mathrm{triv}}$ as $u_{\min }(ℱ)$.

For a large class of constraint families, we obtain a sharp phase transition from trivial instances to requiring brute force running time, assuming the 3-uniform hyperclique hypothesis. For an illustration, see Figure 2.

To future work, we leave the challenge of settling the influence of sparsity for constraint families $ℱ$ with $u_{\min }(ℱ)\in \{0,1,2\}$. As witnessed by the mixed-arity $k$-IS family $ℱ=\{{\text{NAND}}_2,{\text{NAND}}_3\}$ (which has $u_{\min }(ℱ)=2$), settling such families can become technically quite demanding.

Let $H$ be a $3$-Hypergraph⁷⁷7That is, each hyperedge contains at most $3$ vertices. with $n$ vertices and $m$ hyperedges. Let $G$ be the underlying graph of $H$, obtained by removing all hyperedges of arity $3$ from $H$. Notice that any $k$-independent set in $H$ is also a $k$-independent set in $G$. We refer to the $k$-independent sets in $G$ as potential solutions. Formally, let $I(G,k)$ denote the set of all independent sets of size $k$ in $G$ and let $I_{\text{invalid}}(H,k)$ denote the set of all false solutions, i.e. the set of all potential solutions that contain a hyperedge in $H$. We begin with a simple observation that $H$ has a $k$-independent set if and only if $|I(G,k)|-|I_{\text{invalid}}(H,k)|>0$.

Counting the potential solutions, i.e., the value $|I(G,k)|$ can be done via the classical algorithm of Nešetřil and Poljak [24], yielding an $O(n^{\frac{k\omega }{3}})$ bound (if $k$ is divisible by $3$). Hence, the main algorithmic challenge is to efficiently count the invalid solutions, namely those potential solutions that violate at least one hyperedge constraint in $H$. We now turn our attention to this task. For any subset of hyperedges $S$, let $I_S(H,k)$ denote the set of all potential solutions that contain all vertices spanned by $S$; that is, for each $X\in I_S(H,k)$, the induced hypergraph $H[X]$ contains all hyperedges in $S$. Let $E_{\ge 3}$ denote the set of all hyperedges in $H$ that contain at least three vertices. We can now observe that, by definition of $I_{\text{invalid}}$, we have

and for any non-empty set $S\subseteq E_{\ge 3}$

This gives us a natural way to compute the size of $I_{\text{invalid}}$ via the inclusion-exclusion principle as follows.

However, naively enumerating all sets $S$ and computing $|I_S(H,k)|$ fails to improve upon trivial $O(n^k)$ brute-force algorithm, even in the sparse regime $m=O(n)$. To circumvent this issue, we notice that a lot of the “higher-order” terms in the inclusion-exclusion formula are either irrelevant, or redundant. Specifically, such terms either (1) span more than $k$ vertices (irrelevant), or (2) can be obtained by appropriately guessing a “lower-order” term (redundant). Case in point: consider a set $S$ that contains $\left(\genfrac{}{}{0pt}{}{k}{3}\right)$ many edges. The only way that $S$ spans $k$ vertices is if these vertices induce a clique of size $k$ in $H$. However, in that case, for any set $S^{\prime }\subset S$ that contains $k/3$ pairwise non-intersecting hyperedges will span the same vertex set and consequently $I_{S^{\prime }}(H,k)=I_S(H,k)$

This observation will allow us to drastically reduce the number of inclusion–exclusion terms that must be considered, and form the basis of our improved counting algorithm. Intuitively, it brings us to the following win-win scenario: let $S\subset E_{\ge 3}$ of size $>k/3$. Then either (i) the hyperedges in $S$ are “clustered together” and we can get away by guessing a smaller set $S^{\prime }\subset S$ ($S$ is redundant), or (ii) the hyperedges in $S$ are not “clustered together”, but they span more than $k$ vertices, so we never have to consider $S$ at all ($S$ is irrelevant). However, the issue of “clustered edges” cannot be resolved by simply restricting our outer sum to stop at $k/3$, as that would generally lead to a lot of double counting. To bypass this problem, the idea is to impose a total ordering $\prec$ on the hyperedges of $H$. Intuitively, whenever a hyperedge $e\in S$ intersects another hyperedge $e^{\prime }\in E_{\ge 3}$ with $e^{\prime }\prec e$, the algorithm recognizes that all the independent sets containing $V(e)\cup V(e^{\prime })$ have been accounted for in another iteration $S^{\ast }$ that contains $e^{\prime }$, so it avoids counting them again. It remains to formalize and implement this idea efficiently, which we address next.

Let $H$ be an $h$-Hypergraph for some $h\ge 3$, with $n$ vertices and $m={\sum }_{i=2}^h{m}_i$ hyperedges, where each $m_i$ is the number of hyperedges of arity $i$. The goal is to extend the algorithmic framework of detecting $k$-Independent Sets in $3$-Hypergraphs to this more general setting. We first show that a straightforward extension of the techniques developed for $3$-hypergraphs yields an improvement over the brute-force $O(n^k)$ running time for general hypergraphs, provided that $m_i\le O(n^{3-{\epsilon }_i})$ for every arity $i$ (and consequently $m=O(n^{3-\epsilon })$). More precisely, we prove the following proposition, which generalizes the algorithm for $3$-hypergraphs and provides a unified upper bound for $k$-Independent Set in general $h$-hypergraphs.

On a high level, we are taking the same blueprint as in the $3$-hypergraph case: we count the potential solutions and subtract the number of invalid solutions. Recall,

where $G$ denotes the underlying graph of $H$. While the value $|I(G,k)|$ can still be computed efficiently, evaluating $|I_{\text{invalid}}(H,k)|$ becomes more complicated as we increase the arity. As before, we employ the inclusion-exclusion formula, and eliminate the higher order terms in the same way, by using the following formula.

However, the main difficulty lies in computing $|I_S^{\prime }(H,k)|$. Recall that for $3$-hypergraphs, this was achieved by imposing an ordering on hyperedges, and applying the two simple reduction rules,thereby reducing the problem to computing a small independent set in an appropriate graph. For hypergraphs of higher arity, however, when two hyperedges $e,e^{\prime }$ intersect, the set $e^{\prime }\setminus e$ might contain more than two vertices, so simply adding an edge of arity $2$ no longer suffices. A natural generalization of the ”type $2$” reduction rule is to replace $e^{\prime }$ by a hyperedge spanning $e^{\prime }\setminus e$. While this preserves correctness of the construction, crucially, it reduces the problem only to detecting an independent set in hypergraphs, and we can no longer apply the matrix-multiplication-based algorithm to improve upon trivial runtime (see [21] for a detailed discussion). Fortunately, we can circumvent this issue by observing that the new hypergraph has strictly smaller arity than $H$, allowing us to apply induction on the arity, with the $3$-hypergraph algorithm as a base case.

In fact, we improve upon this by using a combination of the three techniques (1) partitioning the hyperedges of $H$ into “sparse” and “dense” components (2) applying the inclusion-exclusion procedure described above to the sparse part (3) using sparse witness enumeration to handle the dense parts. With a careful implementation of these techniques, and by addressing several technical obstacles, we can finally prove the following upper bound for the $k$-Independent Set problem on general hypergraphs.

Perhaps surprisingly, we show that this upper bound is essentially tight: unless either the $k$-Clique Hypothesis, or the $3$-Uniform Hyperclique Hypothesis fails, no significantly faster algorithm is possible. More specifically, by employing appropriate notions of sparse and dense embeddings, we can prove the following theorem.

To study the effect of sparsity systematically in a more general class of problems, we turn to the class of Boolean Constraint Satisfaction Problems (CSPs). Recall that $k$-Independent Set in $h$-hypergraphs can be viewed as a special case of Boolean CSP over the constraint family $ℱ=\{{\text{NAND}}_2,\mathrm{\dots },{\text{NAND}}_h\}$. We formally define this class of problems as follows.

We begin by considering the special case binary constraints families. Perhaps surprisingly, for every such family $ℱ$, and for all values of $\gamma$, we obtain a complete classification of the problem ${\text{Csp}}_k^{\gamma }(ℱ)$: we design an algorithm running in time $T_k(m,n)$, and show its conditional optimality under the $k$-Clique Hypothesis. To obtain such a complete classification across the entire sparsity spectrum, we show that instances of ${\text{Csp}}_k^{\gamma }(ℱ)$ for values , admit a linear time algorithm: $𝒪(n+m)$. The classification becomes much more interesting when we consider the regime $\gamma \ge 1$. In particular we prove the following classification theorem, which is a more formal version of Theorem 3.

By a clever branch and bound approach given in [22], we can generally resolve $0$-invalid constraint functions, essentially allowing to reduce constraint families in the linear regime to $\{\text{EQ}\}$ which in turn can be reduced to a bounded subset-sum instance. For the Subexponential Regime, a fairly simple argument suffices to show that ${\text{Csp}}_k^{\gamma }(\text{IMPL})$ can be reduced to ${\text{Csp}}_k^1(\text{IMPL})$, thus it is unlikely to be improved by exploiting sparsity. Note that this regime is not fully resolved in the dense case, this gap therefore transfers to the sparse setting as well. For the $k$-IS Regime, triviality follows by Turán’s Theorem. The precise details on Regime 1-3 can be found in the full version of the paper.

The Clique Regime turned out to be the most interesting. On the hardness side, we can reduce the dense case to the sparse case using only NAND and one further binary constraint. We reduce the density by blowing up the number of variables accordingly, carefully ensuring that the additional variables are not part of a solution. Here we once again refer to the full version. For the algorithm, we essentially argue that for each family $ℱ$ that belongs to the clique regime we can reduce any instance of ${\text{Csp}}_k^{\gamma }(ℱ)$ efficiently to ${\text{Csp}}_k^{\gamma }(\{\text{NAND},\text{IMPL}\})$, so it suffices to construct an efficient algorithm for this particular family. Our algorithm proceeds in a few steps that when implemented carefully, yield the desired running time.

1. (1)

   (Reduction to Restricted Instance) We first leverage the directed reachability structure induced by IMPL constraints: intuitively, vertices with many descendants are cheap to guess, since including such a vertex in a solution forces all descendants to be set as well. By systematically branching on these vertices and propagating their implications, we can reduce to a restricted instance, where each vertex has at most a single descendant (besides itself) in the directed graph induced by IMPL constraints.

2. (2)

   (Grouping and Sparsity Cutoff) For such restricted instances, we introduce a grouping technique to partition the variables according to their local IMPL structure. Each group corresponds to a small implication neighborhood that can be treated as a single unit. We then establish a sparsity cutoff: if any group is sufficiently large and therefore sufficiently sparse with respect to NAND constraints, we immediately find a solution using Turán-like arguments. As a consequence, we can bound the size of each group and the total number of groups, reducing the problem to a core instance.

3. (3)

   (Removing the $2$-Cycles and Reduction to Triangle Detection) For our last step, we want our Implication-induced graph to be acyclic. We prove the remaining $2$-cycles can only be contained within a small subset of vertices and thus eliminated efficiently. Then, we show how to distribute the groups in a balanced manner and encode valid group selections as vertices in an auxiliary graph. This construction reduces the problem to Triangle Detection, allowing us to leverage matrix multiplication to achieve the desired running time.

In the binary setting we provide an (almost) complete classification of all binary families, condensing the limited landscape into few interesting regimes. We tackle families of unbounded arity by observing a specific parameter that is exploitable both in terms of lower and upper bounds. Precisely, we consider the minimum weight $u_{\min }(f)$ required to violate a constraint function $f$, i.e. let $u_{\min }(f)≔\min \{{\Vert x\Vert }_1\mid f(x)=0\}$ and $u_{\min }(ℱ)≔{\min }_{f\in ℱ}{u}_{\min }(f)$.

Equipped with this parameter, we generalize Turan’s theorem [28] to Boolean CSPs of any arity via a constructive algorithm and define a surprisingly simple gadget to proof hardness conditioned on the ($h-$uniform) $k-$(hyper)clique hypothesis.

Let us first introduce some useful notation and terminology. We will introduce all of the concepts in a more general setting, namely for $h$-hypergraphs for $h\ge 3$, in order to be able to reuse it in the following sections, but note that in this section we will only focus on the special case of $h=3$. Denote by $E_i$ the set of all hyperedges of arity $i$, and analogously, denote by $E_{\ge i}$ the set of all hyperedges of arity at least $i$. Let $\varphi :E(H)\to [m]$ be any fixed bijection. We use $\varphi$ to obtain a total ordering of the hyperedges of $H$. That is, we write $e\prec e^{\prime }$ if . Let $e,e^{\prime }$ be edges that intersect (share common vertices) and assume that $e\prec e^{\prime }$. Intuitively, our goal is to efficiently remove all independent sets $X$ that contain $e$ from $I_S(H,k)$ for any $S$ that contains $e^{\prime }$ to avoid the double counting of the sets spanned by the overlapping edges. We now formally prove that this does not destroy any valid solutions. For any set of hyperedges $S$, let $I_S^{\prime }(H,k)$ be the set of all independent sets $X$ of the underlying graph $G$ of size $k$ satisfying the following two conditions.

1. 1.

   $X$ contains all the vertices spanned by the hyperedges in $S$.

2. 2.

   (Handling the overlapping hyperedges) For any edge $e\in S$ and any edge $e^{\prime }\in E_{\ge 3}$, such that $e\cap e^{\prime }\ne \mathrm{\varnothing }$, if $e^{\prime }\prec e$, then $X$ does not contain $e^{\prime }$.

We now prove that we can safely replace the sets $I_S$ in our inclusion-exclusion formula by the sets $I_S^{\prime }$.

Given two hyperedges $e,e^{\prime }$ such that $e\cap e^{\prime }\ne \mathrm{\varnothing }$, we distinguish between two types of intersections between them. We say that the intersection of two hyperedges $e,e^{\prime }$ is type $i$ if (1) $e^{\prime }\prec e$, and (2) $|e^{\prime }\setminus e|=i$. The idea to construct the sets $I_S^{\prime }$ is to recursively guess an arity-$3$ edge $e$ and then for all edges $e^{\prime }$ in $E_3(H)$ such that the intersection $e,e^{\prime }$ is type $i$, we span the vertex set $(e^{\prime }\setminus e)$ by a hyperedge of arity $i$ in all the descending branches. This ensures that we never consider the independent sets that violate Condition 2 in the definition of the set $I_S^{\prime }$. More formally, we consider the following algorithm.