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 stepbystep 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 wellstudied 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 wellstudied 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 wellknown 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 polynomialtime 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 nonempty 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 graph^{1}^{1}1 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 5tuple , 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 wellstudied 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 PSPACEcomplete or in P for each fixed . In addition, Cardinal et al. [CDEHW18] showed that the problem remains PSPACEcomplete even if is equivalent to monotone NotAllEqual SAT (i.e., each constraint is a set of surjections) and a “variableclause incidence graph” is planar. For the shortest variant, a computational trichotomy is known; Mouawad et al. [MNPR17] proved that the problem is PSPACEcomplete, NPcomplete 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 wellstudied spacial case is CR [BB18, BJLPP14, BC09, BMNR14, BP16, BousquetP16, CCMS16, Cer07, CHJ11, DFFV06, FJP16, HM18, HIZ17c, JKKPP14, OSIZ17, OSIZ18, Wro18]. This problem is PSPACEcomplete 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 PSPACEcomplete 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 polynomialtime 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 PSPACEcomplete even if is a constant for graphs with pathwidth two [Wro18], while it is polynomialtime solvable for graphs with pathwidth one [HIZ14]. Hatanaka et al. [HIZ18] gave fixedparameter 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 wellstudied 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 PSPACEcomplete 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 PSPACEcomplete 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 fixedparameter 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 fixedparameter 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 fixedparameter 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
CSR  PSPACEc.  PSPACEc.  PSPACEc. 
CSR  PSPACEc.  PSPACEc.  PSPACEc. [GKMP09] 
CSR  PSPACEc.  PSPACEc. [Thm. 3]  P [Thm. 3] 
LHR  PSPACEc.  P [Thm. 3]  P 
LCR  PSPACEc.  P [CHJ11]  P 
HR  PSPACEc.  P [Wro15]  P 
CR  PSPACEc. [BC09]  P  P 
Parameter  
CSR  PSPACEc.  PSPACEc. 
CSR  PSPACEc. [GKMP09]  PSPACEc. 
CSR  FPT [Thm. 8]  hard but XP [Thm. 8] 
LHR  FPT  hard but XP 
LCR  FPT  hard but XP 
HR  FPT  hard [Cor. 4] but XP 
CR  FPT  FPT 
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 fixedparameter 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
CSR  PSPACEc.  PSPACEc. 
CSR  PSPACEc.  PSPACEc. 
CSR  PSPACEc.  PSPACEc. 
LHR  PSPACEc.  PSPACEc. [Thm. 5] 
LCR  PSPACEc. [HIZ14, Wro18]  P [HIZ14] 
HR  PSPACEc. [Wro18]  P [Wro18] 
CR  P [HIZ17c]  P 
Parameter  

CSR  PSPACEc.  FPT [Thm. 6]  FPT [Thms. 7, 7]  PSPACEc. 
CSR  PSPACEc.  FPT  FPT  PSPACEc. 
CSR  PSPACEc. [Cor. 5]  FPT  FPT  PSPACEc. 
LHR  FPT [Thm. 6]  FPT  FPT  PSPACEc. 
LCR  FPT [HIZ18]  FPT  FPT  PSPACEc. 
HR  FPT  FPT [Wro18]  FPT  PSPACEc. 
CR  FPT  FPT  FPT  PSPACEc. [Wro18] 
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 .^{2}^{2}2 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 modularwidth, the pathwidth, the treedepth 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 fixedparameter 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 fixedparameter 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 nonBoolean 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 sizeone hyperedge , there must exist a sizetwo 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
In this section, we classify the complexity of the problems for each fixed size of a domain. CSR is PSPACEcomplete for bipartite planar graphs even if .
Proof.
We give a polynomialtime reduction from LCR to CSR. It is known that LCR is PSPACEcomplete 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 polynomialtime 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 yesinstance 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 yesinstance.
We next assume that is a yesinstance 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 yesinstance. ∎
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:
Notice that a clause corresponds to a set . Therefore, corresponds to the set
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 fixedparameter 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 breadthfirst search. Therefore, our algorithm runs in time . ∎
On the other hand, the following theorem implies that a fixedparameter 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].^{3}^{3}3 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 yesinstance 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 PSPACEcompleteness for graphs with bounded parameters
In this section, we show the PSPACEcompletenesses of LHR and CSR for graphs with bounded parameter.
[*] LHR is PSPACEcomplete even if for paths.
CSR is PSPACEcomplete even if for complete graphs.
Proof.
Let be an instance of CSR constructed in Theorem 3. We then add an edge between every nonadjacent 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 Fixedparameter algorithm with respect to graph parameters
We give the following theorems in this section. [*] LHR is fixedparameter tractable when parameterized by . [*] CSR is fixedparameter tractable when parameterized by .
6.1 Reduction rule
In order to prove the above theorems, we give fixedparameter 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 fixedparameter 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 nonempty 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:

and are isomorphic under and .

for every vertex , ;

for every vertex , , that is, and ; and

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 yesinstance 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 fixedparameter tractable when parameterized by . We strengthen it as follows. [*] The shortest variant of CSR is fixedparameter tractable when parameterized by . [*] There exists a fixedparameter 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 wellknown 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 fixedparameter algorithm for CSR is unlikely to exist when parameterized by the size of a hitting set plus . CSR is PSPACEcomplete 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 fixedparameter 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 polynomialtime 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 fixedparameter 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 polynomialtime 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 polynomialtime 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 yesinstance 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
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 onetoone 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 yesinstance. 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
Comments
There are no comments yet.