# Complexity of Reconfiguration Problems for Constraint Satisfaction

Constraint satisfaction problem (CSP) is a well-studied combinatorial search problem, in which we are asked to find an assignment of values to given variables so as to satisfy all of given constraints. We study a reconfiguration variant of CSP, in which we are given an instance of CSP together with its two satisfying assignments, and asked to determine whether one assignment can be transformed into the other by changing a single variable assignment at a time, while always remaining satisfying assignment. This problem generalizes several well-studied reconfiguration problems such as Boolean satisfiability reconfiguration, vertex coloring reconfiguration, homomorphism reconfiguration. In this paper, we study the problem from the viewpoints of polynomial-time solvability and parameterized complexity, and give several interesting boundaries of tractable and intractable cases.

## Authors

• 3 publications
• 10 publications
• 10 publications
• ### Parameterized Complexity of CSP for Infinite Constraint Languages

We study parameterized Constraint Satisfaction Problem for infinite cons...
06/30/2017 ∙ by Ruhollah Majdoddin, et al. ∙ 0

• ### Finding Small Satisfying Assignments Faster Than Brute Force: A Fine-grained Perspective into Boolean Constraint Satisfaction

To study the question under which circumstances small solutions can be f...
05/23/2020 ∙ by Marvin Künnemann, et al. ∙ 0

• ### Reconfiguration of Satisfying Assignments and Subset Sums: Easy to Find, Hard to Connect

We consider the computational complexity of reconfiguration problems, in...
05/10/2018 ∙ by Jean Cardinal, et al. ∙ 0

• ### Algebraic Global Gadgetry for Surjective Constraint Satisfaction

The constraint satisfaction problem (CSP) on a finite relational structu...
05/22/2020 ∙ by Hubie Chen, et al. ∙ 0

• ### On the sampling Lovász Local Lemma for atomic constraint satisfaction problems

We study the problem of sampling an approximately uniformly random satis...
02/16/2021 ∙ by Vishesh Jain, et al. ∙ 0

• ### On the Approximability of Presidential Type Predicates

Given a predicate P: {-1, 1}^k →{-1, 1}, let CSP(P) be the set of constr...
07/09/2019 ∙ by Neng Huang, et al. ∙ 0

• ### Rotational Diversity in Multi-Cycle Assignment Problems

In multi-cycle assignment problems with rotational diversity, a set of t...
11/08/2018 ∙ by Helge Spieker, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Recently, the framework of reconfiguration [IDHPSUU] has been extensively studied in the field of theoretical computer science. This framework models several “dynamic” situations where we wish to find a step-by-step transformation between two feasible solutions of a combinatorial (search) problem such that all intermediate solutions are also feasible and each step respects a fixed reconfiguration rule. This reconfiguration framework has been applied to several well-studied combinatorial problems. (See surveys [ISweb, Nis18, Jan13].)

As an example, we consider the (vertex) coloring reconfiguration problem [BC09, BP16, CHJ11, HIZ17c, Wro18], which is one of the most well-studied reconfiguration problems. Let be a graph and let be a set of colors. A -coloring of is a mapping such that holds for every edge . In the reconfiguration framework, we wish to transform one -coloring into another one by recoloring a single vertex at a time, while always remaining -coloring. (See Figure 1 for example.)

In this paper, we study a reconfiguration variant of the well-known constraint satisfaction problem (CSP, for short), which is a generalization of several combinatorial problems including vertex coloring, Boolean satisfiability, graph homomorphism. The formal definitions of CSP and its reconfiguration variant will be given in Section 2, but we here briefly introduce them. Let be a hypergraph. Let be a set, called a domain; each element of is called a value and we always denote by the size of a domain. In CSP, each hyperedge has a constraint which represents the values allowed to be assigned to the vertices in at the same time, and we wish to find a mapping which satisfies the constraints of all hyperedges in . (See Figure 2 for an example.) In the case of vertex coloring, we can see that every hyperedge consists of two vertices, and has the common constraint that any two different colors can be assigned to the two vertices in the hyperedge at the same time. In the reconfiguration framework for CSP, we are given a CSP instance together with its two mappings satisfying all constraints, and we wish to transform one mapping into the other by changing a value of a single vertex at a time, while always satisfying all constraints.

The reconfiguration problem for CSP has been studied as several spacial cases such as Boolean constraint satisfiability reconfiguration [BMNR14, CDEHW18, GKMP09, MTY10, MTY11, MNPR17, Schwerdtfeger14], homomorphism reconfiguration [BLS18, BLMNS17, BMMN16, BN15, Wro15, Wro18], and (list) coloring reconfiguration [BB18, BJLPP14, BC09, BMNR14, BP16, BousquetP16, CCMS16, Cer07, CHJ11, DFFV06, FJP16, HM18, HIZ14, HIZ17c, HIZ18, IKZ12, JKKPP14, OSIZ17, OSIZ18, Wro18]. We will briefly summarize these results in the next section.

In this paper, we study the reconfiguration problem for CSP and its special cases from the viewpoints of polynomial-time solvability and parameterized complexity, and give several interesting boundaries of tractable and intractable cases. Our results are roughly summarized as follows: We first investigate the complexity of the problem with respect to the size of a domain (summarized in Table 1). We next analyze the (parameterized) complexities with respect to the structure of an input hypergraph (summarized in Tables 3 and 4). We finally explore the boundary of time complexity of the problem; we give some exact algorithms, and a lower bound of the computation time that meets the running times of our algorithms under the exponential time hypothesis.

## 2 Problem definition and results

### 2.1 Our problem

In this subsection, we formally define CSP and its reconfiguration variant by means of hypergraphs.

We first give some terminologies regarding hypergraphs and mappings. A hypergraph is a pair , where is a set of vertices and is a family of non-empty vertex subsets, called hyperedges. A hypergraph is -uniform if every hyperedge consists of exactly vertices. Sometimes, a -uniform hypergraph is simply called a graph and each hyperedge of is called an edge. An edge is sometimes denoted by or for notational convenience. Let and be any sets. We denote by the set of all mappings from to , because we can identify a mapping

with a vector

, where . Let be a mapping. For any subset of , we denote by the restriction of on ; that is, is a mapping in such that for any .

We next define CSP and give some notation. Let be a hypergraph. Let be a set, called a domain; each element of is called a value and we always denote by the size (cardinality) of a domain. In CSP, each hyperedge has a set ; we call a constraint of . If , it is called a trivial constraint. The arity of a constraint of is exactly , and we call an -ary constraint, where . We define the constraint of as the union of all constraints of hyperedges, that is, . For a vertex , a list of is the set . For a hyperedge , we say that a mapping satisfies a constraint of if holds. is a solution if it satisfies all constraints.

An instance of constraint satisfiability is a triple consisting of a hypergraph , a domain , and a constraint assignment to hyperedges over . Then, the problem asks whether there exists a solution or not. Constraint satisfiability includes many combinatorial problems as its special cases as follows.

• Boolean constraint satisfiability is the special case of constraint satisfiability where .

• For an integer , -ary constraint satisfiability is the special case of constraint satisfiability where all constraints are of arity at most , that is, all hyperedges have size at most .

• List homomorphism is the special case of -ary constraint satisfiability where is a -uniform hypergraph (i.e., a graph) and there exists a simple undirected graph with a vertex set , called an underlying graph111 In this paper, we only consider simple undirected underlying graphs, although loops and/or directed edges are often allowed in researches related to graph homomorphisms., such that holds for every edge , where and are lists of and , respectively. In other words, is the set of all homomorphisms from the edge to which respect the lists of and .

• Homomorphism is the special case of list homomorphism where holds for every vertex .

• (List) coloring is the special case of (list) homomorphism where an underlying graph is complete, that is, is a set of all injective mappings from to (which respect the lists of and ).

We then define a reconfiguration variant of constraint satisfiability, that is, constraint satisfiability reconfiguration. Let and be two solutions for an instance of constraint satisfiability. We define the difference between and as the set . We now define the solution graph for as follows. is the set of all solutions for , and two solutions and are connected by an edge if and only if . A walk in is called a reconfiguration sequence. Two solutions and are reconfigurable if and only if there exists a reconfiguration sequence between them.

An instance of constraint satisfiability reconfiguration (CSR for short) is a 5-tuple , where is an instance of constraint satisfiability, and and are two solutions to , called initial and target solutions. Then, the problem asks whether and are reconfigurable or not. Similarly, for each special case P of constraint satisfiability, we define “P reconfiguration” as a special case of CSR. We use the following abbreviations:

• BCSR for Boolean constraint satisfiability reconfiguration;

• -CSR for -ary constraint satisfiability reconfiguration for each integer ;

• (L)HR for (list) homomorphism reconfiguration; and

• (L)CR for (list) coloring reconfiguration.

Relationships between problems are illustrated in Figure 3(a).

### 2.2 Known and related results

There are many literatures which study special cases of CSR and their shortest variants. In the shortest variant, we are given an instance with an integer , and asked whether there exists a reconfiguration sequence of length at most . We here state only the results from the viewpoint of the computational complexity.

One of the most well-studied special cases of CSR is BCSR [BMNR14, CDEHW18, GKMP09, MTY10, MTY11, MNPR17, Schwerdtfeger14]. Gopalan et al. [GKMP09] gave a computational dichotomy for BCSR with respect to a set of logical relations which can be used to define each constraint; the problem is PSPACE-complete or in P for each fixed . In addition, Cardinal et al. [CDEHW18] showed that the problem remains PSPACE-complete even if is equivalent to monotone Not-All-Equal -SAT (i.e., each constraint is a set of surjections) and a “variable-clause incidence graph” is planar. For the shortest variant, a computational trichotomy is known; Mouawad et al. [MNPR17] proved that the problem is PSPACE-complete, NP-complete or in P for each fixed . Bonsma et al. [BMNR14] proved that the shortest variant is -hard when parameterized by even if is equivalent to Horn SAT.

Another well-studied spacial case is CR [BB18, BJLPP14, BC09, BMNR14, BP16, BousquetP16, CCMS16, Cer07, CHJ11, DFFV06, FJP16, HM18, HIZ17c, JKKPP14, OSIZ17, OSIZ18, Wro18]. This problem is PSPACE-complete for and bipartite planar graphs [BC09] but in P for  [CHJ11]. We note that these results (including tractability one) can be extended for LCR. Moreover, it is known that the problem remains PSPACE-complete even if is a fixed constant for several graph classes such as line graphs (for any fixed [OSIZ18], bounded bandwidth graphs [Wro18], and chordal graphs [HIZ17c]. On the other hand, several polynomial-time algorithms are known for subclasses of chordal graphs such as trivially perfect graphs, split graphs [HIZ17c], and -connected chordal graphs [BP16]. For the shortest variant parameterized by , some intractability results are known; it is -hard [BMNR14] and does not admit a polynomial kernelization when is fixed unless the polynomial hierarchy collapses [JKKPP14].

As a generalization of CR, LCR is also studied [HIZ14, HIZ18, IKZ12, OSIZ18, Wro18]. The problem is PSPACE-complete even if is a constant for graphs with pathwidth two [Wro18], while it is polynomial-time solvable for graphs with pathwidth one [HIZ14]. Hatanaka et al. [HIZ18] gave fixed-parameter algorithms for LCR parameterized by and for the shortest variant parameterized by . In contrast, they also showed that the problem is -hard when parameterized only by .

HR is also well-studied as a generalization of CR. Several literatures investigated HR from the viewpoint of graph classes in which a given graph or an underlying graph lies [BLS18, BLMNS17, BMMN16, BN15, Wro15, Wro18]. Brewster et al. [BMMN16] gave a dichotomy for a special case of HR in which is a -circular clique; it is PSPACE-complete if but is in P otherwise. We note that this result generalizes the complexity of CR with respect to , since a complete graph is a -circular clique. It is also known that the problem is PSPACE-complete even if

is an odd wheel

[BLMNS17] or is some fixed graph and is a cycle [Wro18]. On the other hand, it can be solved in polynomial time if is a tree [Wro18] or contains no cycles of length four as a subgraph [Wro15]. Furthermore, a fixed-parameter algorithm is known when parameterized by  [Wro18]; note that it can be easily extended for LHR.

Finally, we refer to the shortest variant of CSR. Bonsma et al. [BMNR14] gave a fixed-parameter algorithm for the shortest variant parameterized by , where is the maximum arity of a constraint. This implies that shortest variants of BCSR and -CSR are fixed-parameter tractable when parameterized by and , respectively. They also showed that the problem is intractable in general if at least one of is excluded from the parameter.

### 2.3 Our contribution

In this paper, we investigate the complexity of CSR and its spacial cases, especially -CSR, -CSR, (L)HR and (L)CR, from several viewpoints.

#### The sizes of a domain and lists

We first classify the complexity of the problems for each fixed size

of a domain in Section 3; recall that corresponds to the number of colors in (L)CR. Together with known results, our results give interesting boundaries of (in)tractability as summarized in Table 1. In particular, our results unravel the boundaries with respect to for -CSR and LHR. The other interesting contrast we show is the boundary between -CSR and LHR for . This might be caused by the difference of variety of constraints; in LHR, a constraint is unique for each pair of lists.

We then extend Theorem 3, which states that -CSR can be solved in polynomial time if . More precisely, we give a fixed-parameter algorithm with respect to , where is the number of vertices whose lists have size more than two. Notice that implies that , and hence our algorithm generalizes Theorem 3. Moreover, this result gives the boundary of the complexity of -CSR between and . We also investigate the parameterized complexity when parameterized only by . The results are summarized in Table 2.

#### Graph parameters

As mentioned in the previous subsection, CR, LCR and HR have been studied from the viewpoint of graph parameters. In this paper, we extend the notion of graph parameters to hypergraphs by taking a “primal graph.” The primal graph of a hypergraph is a graph such that and two distinct vertices are connected by an edge if they are contained in the same hyperedge of . Then, we define any graph parameter of a hypergraph as the parameter of its primal graph .222 For example, when we refer to the treewidth of a hypergraph , it means the treewidth of its primal graph . Note that if is -uniform. Then we can draw Tables 3 and 4 from this viewpoint; throughout the paper, , , and are the modular-width, the pathwidth, the tree-depth and the size of a minimum vertex cover of a given hypergraph, respectively. The relationships between graph parameters are summarized in Figure 3(b); note that tractability (resp., intractability) result propagates downward (resp., upward). We extend several known fixed-parameter algorithms to 2HR (), and CSR ( and ). On the other hand, we show that the first one cannot be extended to -CSR. We also note that a fixed-parameter tractability of CSR parameterized by can be obtained as a corollary of Theorem 6. However, Theorem 7 gives a faster algorithm and Theorem 7 gives an algorithm for the shortest variant.

#### Boundary of time comlexity

In Section 4, we explore the boundary of time complexity of CSR. We first give an algorithm for CSR running in time , where is the number of vertices of a given hypergraph, and hence CSR is in the class XP when parameterized by . On the other hand, we prove that HR is -hard when parameterized by . Furthermore, we prove that -CSR cannot be solved in time under the exponential time hypothesis (ETH). This lower bound matches the running time shown in Theorems 4, 7 and 8.

We move several proofs to Appendices.

### 2.4 Preliminary

Let be a hypergraph, and let be a vertex. We denote by the set of vertices which are adjacent to . For a vertex subset , we denote .

Two hypergraphs and are isomorphic if there exist two bijections and such that holds for each hyperedge . (See Figure 4.) For a hypergraph and a vertex subset , we define the subhypergraph of induced by as the hypergraph such that and . We denote by the subhypergraph of induced by for any vertex subset . (See Figure 5.) We use the notation to denote .

We say that two mappings and are compatible if holds.

Let be an instance of constraint satisfiability. A Boolean vertex is a vertex with , and a non-Boolean vertex is a vertex with . Let and be hyperedges in such that . For a bijection , we denote by the set of mappings from to , where means the composition of mappings. Intuitively, is a “translation” of into a constraint of via a bijection . For example, assume that contains a mapping . If a bijection maps to , respectively, then contains a mapping such that .

Let be an instance of -constraint satisfiability. Without loss of generality, we assume that is connected, , and . Moreover, we can assume that is -uniform as follows. If contains a size-one hyperedge , there must exist a size-two hyperedge (i.e., an edge) from the assumption. Then, we remove from and replace with the set of all solutions satisfying and . Note that this modification does not change the set of solutions and the primal graph.

## 3 Computational complexity with respect to k

In this section, we classify the complexity of the problems for each fixed size of a domain. -CSR is PSPACE-complete for bipartite planar graphs even if .

###### Proof.

We give a polynomial-time reduction from LCR to -CSR. It is known that LCR is PSPACE-complete for bipartite planar graphs even if each list has size at most three [BC09]. Let be such an instance of LCR, and let is a list assignment. Without loss of generality, we assume that . We then construct an instance of -CSR as follows. The idea is to simply replace a value with some value from for each vertex without changing the graph . Let be a vertex such that . Since , there exists a value in . Let be a permutation such that , and for each , and we update as follows:

• ;

• for each neighbor of and each mapping ; and

• for each .

We repeat this operation until there is no vertex such that , and let be the resulting instance. Observe that the construction can be done in polynomial time.

Because we only replace values, is a valid instance of -CSR which is essentially equivalent to . Moreover, is bipartite planar and the domain has only three values, and thus this completes the proof. ∎

In contrast to Theorem 3, there exist polynomial-time algorithms for more restricted cases. We first show that the problem becomes tractable when restricted to LHR and . LHR can be solved in polynomial time if .

###### Proof.

Let be a given instance of LHR such that is the underlying graph with and is a list assignment. We assume without loss of generality that is connected and has at least two vertices. Since is connected, for any homomorphism from to , there exists exactly one connected component of such that holds for every vertex . Moreover, for any two homomorphisms and from to which correspond to different connected components, holds; and hence they are not adjacent in the solution graph. Because the relation of reconfigurability between homomorphisms is transitive, holds if and are reconfigurable, where and are connected components of corresponding to and , respectively. Thus, we can assume that , and let and . If is complete, is also an instance of LCR with , which is solvable in polynomial time [CHJ11]. Otherwise, is a path of length two. Let (resp. ) be the set of all vertices with (). We now claim that is a yes-instance if and only if , which can be checked in polynomial time.

If , then holds. Because contains no edge between and and is a homomorphism from to , must be an independent set of . Therefore, we can independently change the value of each vertex in to obtain ; and hence is a yes-instance.

We next assume that is a yes-instance but . Then, there exist two consecutive homomorphisms and in the reconfiguration sequence such that holds, where is the unique vertex in ; that is, is obtained from by changing the value of along an edge of . Since is connected and has at least two vertices, has at least one neighbor in . Because is a homomorphism, if and only if . Similarly, because is a homomorphism, if and only if . From the definition of , if and only if . We thus have that if and only if , which is a contradiction. Therefore, if is a yes-instance. ∎

We next show that -CSR becomes tractable if is reduced from three to two. -CSR can be solved in polynomial time if .

###### Proof.

We reduce the problem to bijunctive BCSR, which is solvable in polynomial time [GKMP09]. Bijunctive BCSR is a special case of BCSR where and there exists a -CNF formula such that is exactly the set of all satisfying assignments of for every hyperedge . Let be a given instance of -CSR where is a graph and . We now show that for every edge there exists a -CNF formula such that is exactly the set of all satisfying assignments of . For each and , we denote by a literal if or if . Then we define a -CNF formula as follows:

 ϕ(v,w)=⋀(a,b)∈D2∖C(vw)(va∨wb).

Notice that a clause corresponds to a set . Therefore, corresponds to the set

 ⋂(a,b)∈D2∖C(vw)D2∖{(a,b)}=D2∖(D2∖C(vw))=C(vw)

as required. ∎

## 4 Boundary of time complexity

In this section, we explore the boundary of time complexity of the problem. We first give a simple exact algorithm as follows. CSR can be solved in time , and hence CSR is fixed-parameter tractable when parameterized by and in XP when parameterized by , where is the number of vertices of a given hypergraph.

###### Proof.

Our algorithm explicitly construct the solution graph and then check the connectivity between two given solutions. The solution graph has at most vertices and can be constructed in time . The connectivity can be checked in time polynomial in the size of the solution graph by a simple breadth-first search. Therefore, our algorithm runs in time . ∎

On the other hand, the following theorem implies that a fixed-parameter algorithm parameterized only by is unlikely to exist. HR is -hard when parameterized by .

###### Proof.

We give a parameterized reduction from labeled clique reconfiguration, which is defined as follows. Let be a simple graph and let be a positive integer. A -labeled clique (-LC for short) of is a vector consisting of distinct vertices which form a clique. A -labeled clique graph is a graph such that is a set of all -LCs of , and two -labeled cliques and are adjacent if and only if they differ on exactly one component. Then, labeled clique reconfiguration asks for a given graph , an integer , two -LCs and , whether there exists a walk between and in or not. It is known that labeled clique reconfiguration is -hard when parameterized by  [IKOSUY14].333 Although they actually show the similar result for (unlabeled) independent set reconfiguration, the proof can be applied to labeled clique reconfiguration.

We now construct an instance of HR corresponding to an instance of labeled clique reconfiguration. Let be a complete graph with vertices , and let . We define constraints for edges so that is an underlying graph; that is, for each , we define . Observe that is an instance of homomorphism with vertices. The remaining components, two solutions and , are defined as follows. For any -LC of , we define be a mapping such that for each . Since holds for each distinct , is a solution of . Thus, let and . This completes the construction of . Finally, is a yes-instance if and only if is, because and are isomorphic under a mapping . ∎

The following also follows as a corollary. HR is -hard when parameterized by , where is any parameter which is polynomially bounded in .

We finally give a lower bound on the computation time, which matches the running times of Theorem 4 and two theorems which will be shown later. [*] Under ETH, there exists no algorithm solving -CSR in time .

## 5 PSPACE-completeness for graphs with bounded parameters

In this section, we show the PSPACE-completenesses of LHR and -CSR for graphs with bounded parameter.

[*] LHR is PSPACE-complete even if for paths.

-CSR is PSPACE-complete even if for complete graphs.

###### Proof.

Let be an instance of -CSR constructed in Theorem 3. We then add an edge between every non-adjacent pair, and give a trivial constraint to every added edge . Notice that this modification does not change the solution graph, and thus the reconfigurability. ∎

## 6 Fixed-parameter algorithm with respect to graph parameters

We give the following theorems in this section. [*] LHR is fixed-parameter tractable when parameterized by . [*] CSR is fixed-parameter tractable when parameterized by .

### 6.1 Reduction rule

In order to prove the above theorems, we give fixed-parameter algorithms which are based on the concept of “kernelization”. That is, we compute from the given instance into another instance whose size depends only on the parameter. After that, we can solve the problem by using Theorem 4.

In this subsection, we show some useful lemma, which compresses an input hypergraph into a smaller hypergraph with keeping the reconfigurability. We note that this is the extension of the lemma given in [HIZ18] to obtain a fixed-parameter algorithm for LCR parameterized by . The main idea is to “identify” two subgraphs which behave in the same way with respect to the reconfigurability.

We now formally characterize such subhypergraphs and explain how to identify them. Let be an instance of CSR. For each vertex , we define as a pair consisting of the initial and the target value assignments of . Let and be two non-empty vertex subsets of such that , and . Assume that . Let , , and . Two induced subhypergraphs and are identical if there exist two bijections and which satisfy the following four conditions:

1. and are isomorphic under and .

2. for every vertex , ;

3. for every vertex , , that is, and ; and

4. for every hyperedge , , where .

See Figure 6 for an example.

We next define another instance as follows:

• ;

• and ; and

• for each , , where and .

Intuitively, is obtained by restricting all components (hypergraphs, mappings in constraints, and two solutions) of on . We say that is obtained from by identifying with .

Then, we have the following lemma, which says that and are equivalent with respect to the feasibility. [*] Let be a mapping from to . Then, is a solution for if and only if there exists a solution for such that . Notice that Lemma 6 ensures that the “restricted” instance is a valid instance of CSR.

We now give the following key lemma, which says that and are equivalent with respect to even the reconfigurability. [*, Reduction rule] Let and be instances of CSR defined as above. Then, is a yes-instance if and only if is.

## 7 Vertex cover

In this section, we consider the size of a minimum vertex cover. Note that Theorem 6 implies CSR is fixed-parameter tractable when parameterized by . We strengthen it as follows. [*] The shortest variant of CSR is fixed-parameter tractable when parameterized by . [*] There exists a fixed-parameter algorithm for CSR parameterized by which runs in time .

### 7.1 Discussions

We conclude this section by discussing hitting sets on hypergraphs, which is a well-known generalization of vertex covers on graphs. Although a hitting set of a -uniform hypergraph is equivalent to a vertex cover of the graph, such an equivalence does not hold for general hypergraphs. Thus, it is worth considering the complexity of CSR with respect to the size of a hitting set of a given hypergraph. We have the following theorem, which implies that a fixed-parameter algorithm for CSR is unlikely to exist when parameterized by the size of a hitting set plus . -CSR is PSPACE-complete even for hypergraphs with a hitting set of size one and .

###### Proof.

Let be an instance constructed in Theorem 3. Briefly speaking, we add a new vertex to , include it in every edge , and modify the constraints so that a value assignment to does not affect any other vertices. More precisely, we construct a new instance as follows. Let and , where is a new vertex which is not in . Then, has a hitting set of size one. For each hyperedge , we let . We finally extend (resp., ) to (resp., ) by setting (resp., ). This completes the construction. is equivalent to by ignoring a value assignment to . ∎

## 8 Extension of Theorem 3

In this section, we extend Theorem 3 to a more general situation. [*] There exists a fixed-parameter algorithm for -CSR parameterized by which runs in time .

## 9 Conclusion

In this paper, we studied CSR and its special cases from the viewpoints of polynomial-time solvability and parameterized complexity, and gave several interesting boundaries of tractable and intractable cases with respect to the size of a domain (Table 1), the size of lists (Table 2), and the structure of an input hypergraph (Tables 3 and 4). Moreover, we gave some exact algorithms, and a lower bound of the computation time that meets the running times of our algorithms under ETH.

We leave as an open question whether some of our algorithms can be extended for the shortest variant or not. In particular, the extensions of the fixed-parameter algorithms parameterized by (Theorem 6) and (Theorem 6), respectively, are interesting. We note that the reduction rule (Lemma 6) does not preserve the shortest length of a reconfiguration sequence since we just remove vertices.

## Appendix A Proof of Theorem 4

We give a polynomial-time reduction from -clique, which is defined as follows. An instance of -clique is a graph with the vertex set ; we denote for each . Then, the problem asks whether there exists a clique such that for every . It is known that there exists no algorithm solving -clique in time under ETH [ETHlb15, Theorem 14.12]. We will present a polynomial-time transformation from an instance of -clique to an instance of -CSR such that

• a graph has vertices and a domain has values; and

• is a yes-instance if and only if is.

If there exists an algorithm solving -CSR in time , an execution of for the transformed instance yields an algorithm solving -clique in time

 O∗((k+n)o(k+n))=O∗((2κ+3)o(2κ+3))=O∗((κ2)o(2κ+3))=O∗(κo(κ)).

Before constructing , we first reformulate -clique as a special case of -ary constraint satisfiability by a similar idea of the proof of Theorem 4. Let be a complete graph with vertices , and let . We construct each constraint so that assigning a value to a vertex corresponds to choosing a vertex as a member of a clique . That is, we define . Observe that we can simultaneously assign and to and , respectively, if and only if and are adjacent in . Therefore, and are equivalent. Clearly, holds.

We now construct an instance of -CSR as follows. A graph is obtained from by adding two new vertices and and edges . These added vertices will form a key component which links the existence of a solution of with the reconfigurability of . Clearly, and hold. We first construct the constraints of the original graph . For each edge , we add to a constraint , all mappings which contain ; that is, . We have the following observation.

###### Observation 1.

Solutions of in which no vertices are assigned one-to-one corresponds to solutions of the original instance .

We next define the constraints regarding and . The constraint of is defined as . For each , we let . Then, we have the following observation.

###### Observation 2.

we can assign to if and only if no other vertices are assigned .

Finally, we define two solutions and as follows:

• for each vertex , let ; and

• let and .

In order to show the correctness, it suffices to show the following lemma. has a solution if and only if is a yes-instance. We first show the if direction. Assume that and are reconfigurable. Then, a reconfiguration sequence must contain a solution such that . Otherwise, values of and can never be changed because only allowed assignment to