On the Parallel Parameterized Complexity of the Graph Isomorphism Problem

11/24/2017 ∙ by Bireswar Das, et al. ∙ IIT Gandhinagar 0

In this paper, we study the parallel and the space complexity of the graph isomorphism problem () for several parameterizations. Let H={H_1,H_2,...,H_l} be a finite set of graphs where |V(H_i)|≤ d for all i and for some constant d. Let G be an H-free graph class i.e., none of the graphs G∈G contain any H ∈H as an induced subgraph. We show that parameterized by vertex deletion distance to G is in a parameterized version of ^1, denoted -^1, provided the colored graph isomorphism problem for graphs in G is in ^1. From this, we deduce that parameterized by the vertex deletion distance to cographs is in -^1. The parallel parameterized complexity of parameterized by the size of a feedback vertex set remains an open problem. Towards this direction we show that the graph isomorphism problem is in -^0 when parameterized by vertex cover or by twin-cover. Let G' be a graph class such that recognizing graphs from G' and the colored version of for G' is in logspace (Ł). We show that for bounded vertex deletion distance to G' is in Ł. From this, we obtain logspace algorithms for for graphs with bounded vertex deletion distance to interval graphs and graphs with bounded vertex deletion distance to cographs.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

Two graphs and are said to be isomorphic if there is a bijection such that for all pairs , if and only if . Given a pair of graphs as input the problem of deciding if the two graphs are isomorphic is known as the graph isomorphism problem (). Whether this problem has a polynomial-time algorithm is one of the outstanding open problem in the field of algorithms and complexity theory. It is in but very unlikely to be -complete as it is in  [7]. Recently Babai [4] designed a quasi-polynomial time algorithm for improving the best previously known runtime  [2, 36]. However, efficient algorithms for have been discovered for various restricted classes of graphs e.g., planar graphs [25], bounded degree graphs [30], bounded genus graphs [32], bounded tree-width graphs [6] etc.

For restricted classes of graphs the complexity of has been studied more carefully and finer complexity classifications within have been done. Lindell [28] gave a deterministic logspace algorithm for isomorphism of trees. In the recent past, there have been many logspace algorithms for for restricted classes of graphs e.g., or minor free graphs [18], planar graphs [17], bounded tree-depth graphs [16], bounded tree-width graphs [20]

etc. On the other hand parallel isomorphism algorithms have been designed for graphs with bounded eigenvalue multiplicity  

[3], bounded color class graphs [31] etc.

The graph isomorphism problem has been studied in the parameterized framework for several graph classes with parameters such as the tree-depth [8], the tree-distance width [35], the connected path distance width [33] and recently the tree-width which corresponds to a much larger class  [29]. A more detailed list of algorithms for in parameterized setting can be found in [9].

While there are many results on the parallel or the logspace complexity of problems in the parameterized framework [19], very little is known in this direction for . The parameterized analogues of classical complexity classes have also been studied in [12, 22, 21]. The class - is the family of parameterized problems that are in after a pre-computation on the parameter, where is a complexity class. In this paper we study the graph isomorphism problem from a parameterized space and parallel complexity perspective. Recently Chandoo [14] showed that for circular-arc graphs is in - when parameterized by the cardinality of an obstacle set.

Since the graph isomorphism problem parameterized by tree-width has a logspace [20] as well as a separate algorithm [29] it is natural to ask if we can design a parameterized parallel algorithm for this problem. In fact, the parallel complexity of parameterized by the well known but weaker parameter feedback vertex set number (FVS) is also unknown. We make some progress in this direction by showing that parameterized by the size of a vertex cover, which is a weaker parameter than the FVS, is parallelizable in the parameterized setting.

Let be a graph class characterized by a finite set of forbidden induced subgraphs (see Section 3 for the formal definition). Kratsch et al. [27] gave an algorithm for parameterized by the distance to by taking a polynomial time colored graph isomorphism algorithm for graphs in as a subroutine. In Section 3, we show that the result of [27] is parallelizable in the parameterized framework. More precisely, we give a - algorithm for this problem. As a consequence, observe that parameterized by the distance to cographs is in -.

Using bounded search tree method we also design a parallel recognition algorithm for graphs parameterized by the distance to . One would ask if the problem is in - using the same method as in [12] and [19]. However, the recent corrigendum Cai et al. [13] suggests that this may need completely new ideas.

In the above mentioned parallel analogue of the result by Kratsch et al. [27], is a class of graphs characterized by a finite set of forbidden induced subgraphs. Instead of that if we take to be the set of bounded tree-width graphs then the parallel parameterized complexity is again open. Note that the analogous preconditions of the theorem by Kratsch et al. [27] in this scenario is met by the logspace algorithm for bounded tree-width graphs by Elberfeld et al. [20]. In fact, the problem is open even when is just the set of forests because this is the same problem: parameterized by feedback vertex set number. We study the graph isomorphism problem for bounded distance to any graph class under reasonable assumptions: the colored version of for the class and the recognition problem for are in . We give a logspace isomorphism algorithm for such classes of graphs.

In Section 4, we show that is in - when parameterized by the vertex cover number. By using the recognition algorithm for graphs parameterized by the vertex cover number due to [5], we first design a recognition algorithm for graphs parameterized by twin-cover number. We then prove that the graph isomorphism problem parameterized by twin-cover is in -.

Parameter/Problem Recognition Graph Isomorphism
Vertex Cover -[5] - [*]
Twin Cover - - [*]
Distance to -free graphs - [*] - [*]
Feedback Vertex set number Open for - Open for -
Table 1: Parallel/Space complexity results/status on the graph isomorphism problem parameterized by various parameters. [*] indicates results presented in this paper.

2 Preliminaries

The basic definitions and notations of standard complexity classes are from [1] and the definitions of parameterized versions of complexity classes are from [21, 12, 34]. A parameterized problem is pair of a language and a parameterization that maps input instances to natural numbers, their parameter values111Often we write in stead of .. The class - is defined to be the family of problems that are in after a precomputation on the parameter where is a complexity class.

Definition 1

[21] For a complexity class , a parameterized problem belongs to the para class - if there is an alphabet , a computable function and a language with such that for all we have .

If the complexity class is then we get the complexity class -. The following equivalent definition of - is convenient when designing - algorithms.

Definition 2

[21] A parameterized problem over is in - if there is function such that the question can be decided within space .

The parameterized parallel complexity classes are defined by using the basic complexity classes in place of in above and basic gates ( and gates) as follows [34]:

- (-): The class of languages that are decidable via family of circuits over basic gates (resp. together with threshold gates) with unbounded fan-in, size , and depth if and depth if . From the definition of -, we know that for two complexity classes and , if and only if -- [5]. Hence we have the following relation between complexity classes ----. There exists a circuit class - in between - and - which is strictly more powerful than -. The definition of - is as follows.

Definition 3

[5] - is a class of languages that are decidable via family of circuits over basic gates with unbounded fan-in, size , and depth where and are computable functions.

The depth of the circuits in this class is bounded by a function that depends only on the parameter. We have --- and ---. We do not know relation between - and -. The computational versions of all the above circuit classes can be defined in the usual manner by having multiple output gates.

In this paper, the graphs we consider are undirected and simple. For a graph , let and denote the vertex set and edge set of respectively. An edge is denoted as for simplicity. For a subset , the graph denotes the subgraph of induced by the vertices of . We use notation to refer the graph obtained from after removing the vertex set . For a vertex , denotes the set of vertices adjacent to and . For a set , denoted as .

In this paper we study problems similar to the graph modification problems where given a graph , and a graph class the task is to apply some graph operations (such as vertex or edge deletions) on to get a graph in . For example, if is the class of edgeless graphs then the number of vertices to be deleted from graph to make it edgeless is the vertex cover problem. For a graph class , the distance to of a graph is the minimum number of vertices to be deleted from to get a graph in . For a positive integer , we use to denote the family of graphs such that each graph in this family can be made into a graph in by removing at most vertices.

Cographs are -free graphs i.e., they do not contain any induced paths on four vertices. Interval graphs are the intersection graphs of a family of intervals on the real line. A graph is a threshold graph if it can be constructed recursively by adding an isolated vertex or a universal vertex.

The parameterized Vertex Cover problem has input a graph and a positive integer . The problem is to decide the existence of a vertex set of size at most such that for every edge , either or . A minimal vertex cover of a graph is a vertex cover that does not contain another vertex cover.

Definition 4

Let be a graph. The set is said to be twin-cover of if for every edge either
(a) or , or (b) and are twins222Two vertices and are twins if ..

An edge between a pair of twins is called a twin edge. The graph obtained by removing a twin-cover from is a disjoint collection of cliques [23].

A kernel for a parameterized problem is an algorithm which transforms an instance of to an equivalent instance in polynomial time such that and for some computable function . For more details on parameterized complexity see [19].

In this paper, a coloring of a graph is just a mapping of the vertices of a graph to a set of colors, and it need not be proper.

Definition 5

The colored graph isomorphism problem is to decide the existence of a color preserving isomorphism between a pair of colored graphs and , i.e., there exists a bijection mapping , satisfying the following conditions: 1) for all 2) for all .

3 for Distance to a Graph Class is in -

In this Section, first we give a generic method to solve for graphs from in - provided there is a logspace colored algorithm for graphs in and a - algorithm for enumerating vertex deletion sets.

Theorem 3.1

Let be a any graph class. Suppose enumerating all the vertex deletion sets of is in - and the colored graph isomorphism problem for graphs from is in . Then the graph isomorphism problem for graphs from is in -.

Proof

Let be a logspace algorithm to check whether two given input colored graphs and from are isomorphic. We assume that graphs and are at a distance at most from . If and belong to then use the algorithm to check the isomorphism between and . Otherwise we consider a vertex deletion set of minimum size (say ) such that and all possible vertex deletion sets of size for such that for all given as input. Notice that .

For each , the algorithm iterates over all possible isomorphisms between to , and tries to extend them to isomorphisms from to with the help of the colored graph isomorphism algorithm applied on some colored versions of and , where the colors of the vertices are determined by their neighbors in the corresponding deletion set. A crucial observation is that any bijective mapping from to can be viewed as a string in and can be encoded as a string of length . The string is encodes the map that sends the th vertex in to the th vertex in .

For all algorithm iterates over all bijective mappings from to using string of length . Next it checks whether the bijective mapping is actually an isomorphism from to . For each isomorphism from to , we need to check whether this isomorphism can be extended to an isomorphism from to by using algorithm . We color the vertices of according to their neighbourhood in . Two vertices of get same color if they have the same neighbourhood in . A vertex in and a vertex in will get same color if . We query algorithm with input the graphs and colored as above. If the algorithm says ‘yes’ then and the algorithm accepts the input. Otherwise it tries the next isomorphism from to . If for all and all isomorphisms from to , the algorithm rejects then the we conclude that and the algorithm rejects the input.

We note few more details of the algorithm to demonstrate that it uses small space. The enumeration over the ’s can be done using a bit counter. To check if two vertices in and in have same color in logspace we can inspect each vertex in , find out if it in , find out if it is a neighbour of , and check if its image under is a neighbour of . This needs constantly many counters. ∎

Next we give a - recognition algorithm for graphs parameterized by the distance to a graph class by using the bounded search tree technique, where is characterized by finitely many forbidden induced subgraphs.

Definition 6

[27] A class of graphs is characterized by finitely many forbidden induced subgraphs if there is a finite set of graphs such that a graph is in if and only if does not contain as an induced subgraph for any .

Let and be classes as defined above. We use the bounded search tree technique  [19, 11] to find a set of size at most such that . In this method we can compute all deletion sets of size at most . Let be the size of the largest forbidden induced subgraph in . The algorithm constructs a tree as follows. The root of the tree is labelled with the empty set. It finds a forbidden induced subgraph of size at most in . Any vertex deletion set must contain a vertex of . We add many children to the root labelled with vertices of . In general if a node is labelled with a set , then we find a forbidden induced subgraph in and create many children for the node labeled and label each child with , where . If there exists a node labeled with a set in of size at most such that , then is a required vertex deletion set. From this, we also know that there are at most minimal vertex deletion sets of size at most . Using the same process we can also find all the minimal vertex deletion sets of size at most .

Cai et al. [12] implemented bounded search tree method and kernelization to find the vertex cover in - in 1997. However, the implementation of bounded search tree method in - was reported to have some errors [13]. Thus, this paper seems to give the first implementation of bounded search tree method in -. Let us recall form Section 2, that there is no known relation between - and -.

Lemma 1

Let be a class of graphs characterized by finitely many forbidden induced subgraphs with for all where is a constant. On input a graph , the problem of computing all vertex deletion sets of size at most is in - where is the parameter.

Proof

The idea to implement the bounded search tree method in - is as follows:

Consider the set of all subsets of size at most that induce a forbidden subgraph in . We order these subsets lexicographically to obtain a list where for each , is isomorphic to some graph in . Notice that . The list can be computed in - by first producing all subsets of of size at most and then keeping only those that induce a subgraphs isomorphic to some in . Observe that any vertex deletion set must contain at least one vertex from each for all . The algorithm uses all strings in parallel to pick the vertex deletion sets of size at most as follows: Let us concentrate on the part of the circuit that processes a particular string . Initially the deletion set is empty. The algorithm puts the th vertex (in lexicographic order) of in if . If the computation ends in this part of the circuit. Suppose the algorithm has already picked vertices using . It picks the th vertex using . To do so it picks the first set in the list such that (if we say that is ‘hit’ by ). Then it puts the th vertex of in if . Otherwise the computation ends in the part processing . If on or before reaching we have obtained a set such that for all , the algorithm has successfully found a vertex deletion set. We say that the algorithm is in phase if it processing .

To see that the algorithm can be implemented in -, we just need to observe that in each phase the algorithm has to maintain the list of sets in that are not yet hit by . The depth of the circuit is and the total size is . ∎

We implemented the bounded search tree method in -. This implementation can be used not only to recognize the graph class defined in the Definition 6 but also, as we can show, for designing - algorithms for the problems Restricted Alternating Hitting Set and Weight -Cnf Satisfiability. The problems are as follows:
Problem 1: [19, 12] Restricted Alternating Hitting Set
Instance: A collection of subsets of a set with for all .
Parameter: Two positive integers .
Question: Does Player I have a win in at most moves in the following game? Players play alternatively and choose unchosen elements, until, for each some member of has been chosen. The player whose choice this happens to be wins.
Problem 2: [19, 12] Weight -Cnf Satisfiability
Instance: Boolean formula in conjunctive normal form with maximum clause size where is fixed.
Parameter: A positive integer .
Question: Does have a satisfying assignment with at most literals true?

Theorem 3.2

The following problems are in -:
(i) Restricted Alternating Hitting Set.
(ii) Weight -Cnf Satisfiability.

Downey et al. [19] gave algorithms for these two problems by using bounded search tree method. We implemented the bounded search tree method in -. Thus, these two problems are also in -.

The next theorem is obtained by replacing the complexity class - by - in Theorem 3.1. The proof of the theorem uses similar ideas and the implementation is easier. Moreover, because of Lemma 1 we do not have to assume the existence of an algorithm that outputs all the vertex deletion sets.

Theorem 3.3

Let be a class of graphs characterized by finitely many forbidden induced subgraphs with for all where is a constant. Suppose the colored graph isomorphism problem for graphs from is in . Then the graph isomorphism problem for graphs from is in -.

Corollary 1

The graph isomorphism problem parameterized by the distance to cographs is in -.

Proof

Recall that cographs are graphs without any induced . The colored graph isomorphism for cographs was shown to be in using logspace algorithm to find the modular decomposition [24]. From this along with Theorem 3.3 and Lemma 1, we deduce that the graph isomorphism problem for distance to cographs is in -.∎

As a consequence of the above corollary, we can also solve graph isomorphism problem for some of the other graph classes e.g., distance to cluster (disjoint union of cliques), distance to threshold graphs in - by using the generalized meta Theorem 3.3.

For larger parameters like vertex-cover, distance to clique and twin-cover, we can get better complexity theoretic results which we discuss in the following section.

4 Parameterized by Vertex Cover is in -

In this section we give a parameterized parallel algorithm for parameterized by vertex cover. Sam Buss [10] showed that Vertex Cover admits a polynomial kernel. Based on this kernelization result, Cai et al. [12], Elberfeld et al. [21] and Bannach et al. [5] showed that Vertex Cover is in -, - and - respectively. These methods not only determines the existence of a vertex cover of size at most but can also output all vertex covers of size at most in -. We give a brief overview of the procedure to enumerate all vertex covers of size at most by using kernelization method given in [12, 5, 21].

Observe that any vertex of degree more than must belong to any vertex cover of a given graph . For the graph , consider the set . If is more than then we declare that there is no sized vertex cover. Let us assume . Consider the set of vertices that have at least one neighbour outside . Notice that none of the edges in are covered by . Let be a vertex cover of . It is easy to see that forms a vertex cover of . On the other hand if is a vertex cover of then is a vertex cover of . If the cardinality of is more than then reject (because the graph induced by vertices with vertex cover and all vertices degree bounded by has no more than vertices). So the cardinality of is not more than . We can use the best known vertex cover algorithm [15] to find the vertex cover on the sub graph induced by vertices . Elberfeld et al. [21] pointed that the parallel steps of this process are the following:

  • Checking whether the vertex belongs to .

  • Checking whether at most .

  • Checking whether at most .

  • Computing the induced subgraph from .

The computation of above steps can be implemented by - circuits [5]. The above process finds all vertex covers of size at most by enumerating all the possible binary strings on length .

Theorem 4.1

The graph isomorphism problem parameterized by vertex cover is in -.

Proof

Given two input graphs and with vertex cover of size at most , we need to test if to are isomorphism in -. Using the kernelization method of Bannach et al. [5] we can recognize whether these two graphs have same sized vertex covers or not. For the graph we find a minimal vertex cover of size at most and for graph we find all minimal vertex covers , each of size at most . Notice that is at most . We know that if then for some . We try all isomorphisms from the minimal vertex cover of to each minimal vertex cover of . Suppose via . We need to extend this isomorphism from the independent set to . There are at most isomorphisms between to . The algorithm processes all pairs and all the isomorphisms in parallel.

For each isomorphism , we need to check whether this can be extended to an isomorphism between to . We partition the vertices of the graph into at most sets (called ‘types’) based on their neighborhood in . For each let . It is not hard to see that if and only if there is a minimal vertex cover of and an isomorphism from to such that for each , . The problem of testing whether is isomorphic to reduces to counting the number of vertices in each type. We represent each type using an -length binary string, where entry is one if belongs to that type and zero otherwise. Since the Bit Count333Counting the number one’s in length binary string. problem is in , counting the number of vertices in a type can be implemented using a circuit. In summary, for each and each isomorphism between and , and for each we check whether . This completes the proof. ∎

Corollary 2

The graph isomorphism problem is in - when parameterized by the distance to clique.

Proof

We apply Theorem 4.1 to the complements of the input graphs. ∎

Corollary 3

The graph isomorphism problem parameterized by the size of a twin-cover is in -.

Proof

To find the twin-cover, we first remove all the twin edges and then compute a vertex cover of size at most in the resulting graph as was done in [23]. The first step runs through all edges and deletes an edge if it is a twin edge. Next it finds a vertex cover in the resulting graph which can be done in - [5]. Thus, computing all the twin-covers can be done in -.

Now we describe the process of testing isomorphism. The idea for testing isomorphism of the input graphs parameterized by the size of a twin-cover is similar to that in the proof of Theorem 4.1. Let be a fixed twin-cover in and be a twin-cover in of same size. The algorithm processes all such pairs in parallel. First fix an isomorphism (say ) from to and try to extend it to to . Again, all such isomorphisms are processed in parallel. We know that the graph obtained by removing a twin-cover from is a disjoint collection of cliques. Any two vertices in a clique have same neighbourhood in i.e., if then . Thus, the ‘type’ of a clique is completely determined by the neighbourhood of any of the vertices in the vertex deletion set, and the size of the clique. Formally, with respect to the isomorphism , a clique in and a clique in have same type if 1) and 2) . The algorithm needs to check that the number of cliques in each type is same in both the graphs. This problem can again be reduced to instances of the Bit Count problem.

It is easy to see that, the above process can be implemented in -.∎

5 Logspace Algorithms for Bounded Distance to Graph Classes

In this Section, we show that for fixed for graphs in is in if the colored for graphs in is in where is a graph class. From this result we obtain that for and graphs is in . Note that these results are not in the parameterized complexity theory framework. The proof of the following theorem given in appendix.

Theorem 5.1

Let be a fixed and be a class of graphs. Suppose the problem of deciding if a given graph is in and the colored graph isomorphism problem for graphs in is in . Then the graph isomorphism problem for graphs from is in .

Suppose graph class is define as in Definition 6. It is not hard to see the problem of deciding if a graph is in a class characterized by finitely many forbidden induced subgraphs is in logspace (See Lemma 2 in the Appendix). The proof of the next corollary follows from Lemma 2 and Theorem 5.1.

Corollary 4

Let the graph class be characterized by finitely many forbidden induced subgraphs with for all where is a constant. The graph isomorphism problem for graphs with bounded vertex deletion from is in provided the colored graph isomorphism problem for graphs from is in .

Corollary 5

The graph isomorphism problem is in for following graph classes: 1) distance to interval graphs 2) distance to cographs.

Proof

The proof of (1), follows from Theorem 5.1 and the logspace algorithm for colored for interval graphs (see [26]).
The proof of (2), follows from Corollary 4 and the logspace isomorphism algorithm for colored for cographs [24].∎

6 Conclusion

In this paper we showed that graph isomorphism problem is in - when parameterized by the vertex cover number of the input graphs. We also studied the parameterized complexity of graph isomorphism problem for the class of graphs characterized by finitely many forbidden induced subgraphs. We showed that graph isomorphism problem is in - for the graphs in if there is an algorithm for colored- for the graph class . From this result, we show that parameterized by the distance to cographs is in -.

The following questions remain open. Can we get a parameterized logspace algorithm for parameterized by feedback vertex set number? Does the problem admit parameterized parallel algorithm? Elberfeld et al. [20] showed that is in logspace for graphs of bounded tree-width. In this paper, we showed that for some subclasses of bounded clique-width graphs is in . It is an interesting open question to extend these results to bounded clique-width graphs.

References

  • [1] Arora, S., Barak, B.: Computational complexity: a modern approach. Cambridge University Press (2009)
  • [2] Babai, L.: Moderately exponential bound for graph isomorphism. In: Fundamentals of Computation Theory. pp. 34–50. Springer (1981)
  • [3] Babai, L.: A las vegas-nc algorithm for isomorphism of graphs with bounded multiplicity of eigenvalues. In: Foundations of Computer Science, 1986., 27th Annual Symposium on. pp. 303–312. IEEE (1986)
  • [4]

    Babai, L.: Graph isomorphism in quasipolynomial time. In: 48th Annual ACM SIGACT Symposium on Theory of Computing. pp. 684–697. ACM (2016)

  • [5] Bannach, M., Stockhusen, C., Tantau, T.: Fast parallel fixed-parameter algorithms via color coding. In: 10th International Symposium on Parameterized and Exact Computation. p. 224 (2015)
  • [6] Bodlaender, H.L.: Polynomial algorithms for graph isomorphism and chromatic index on partial -trees. Journal of Algorithms 11(4), 631–643 (1990)
  • [7] Boppana, R.B., Hastad, J., Zachos, S.: Does co-NP have short interactive proofs? Information Processing Letters 25(2), 127–132 (1987)
  • [8] Bouland, A., Dawar, A., Kopczyński, E.: On tractable parameterizations of graph isomorphism. In: Parameterized and Exact Computation, pp. 218–230. Springer (2012)
  • [9] Bulian, J., Dawar, A.: Graph isomorphism parameterized by elimination distance to bounded degree. Algorithmica 75(2), 363–382 (Jun 2016)
  • [10] Buss, J.F., Goldsmith, J.: Nondeterminism within P*. SIAM Journal on Computing 22(3), 560–572 (1993)
  • [11] Cai, L.: Fixed-parameter tractability of graph modification problems for hereditary properties. Information Processing Letters 58(4), 171–176 (1996)
  • [12] Cai, L., Chen, J., Downey, R.G., Fellows, M.R.: Advice classes of parameterized tractability. Annals of pure and applied logic 84(1), 119–138 (1997)
  • [13] Cai, L., Chen, J., Downey, R.G., Fellows, M.R.: Advice classes of parameterized tractability-corrigendum (2017)
  • [14] Chandoo, M.: Deciding circular-arc graph isomorphism in parameterized logspace. In: 33rd Symposium on Theoretical Aspects of Computer Science (2016)
  • [15] Chen, J., Kanj, I.A., Xia, G.: Improved upper bounds for vertex cover. Theoretical Computer Science 411(40-42), 3736–3756 (2010)
  • [16] Das, B., Enduri, M.K., Reddy, I.V.: Logspace and fpt algorithms for graph isomorphism for subclasses of bounded tree-width graphs. In: International Workshop on Algorithms and Computation. pp. 329–334. Springer (2015)
  • [17] Datta, S., Limaye, N., Nimbhorkar, P., Thierauf, T., Wagner, F.: Planar graph isomorphism is in log-space. In: 24th Annual IEEE Conference on Computational Complexity. pp. 203–214 (2009)
  • [18] Datta, S., Nimbhorkar, P., Thierauf, T., Wagner, F.: Graph isomorphism for K-free and K-free graphs is in log-space. In: LIPIcs-Leibniz International Proceedings in Informatics. vol. 4 (2009)
  • [19] Downey, R.G., Fellows, M.R.: Fundamentals of parameterized complexity. Springer Science & Business Media (2013)
  • [20] Elberfeld, M., Schweitzer, P.: Canonizing graphs of bounded tree width in logspace. In: 33rd Symposium on Theoretical Aspects of Computer Science (2016)
  • [21] Elberfeld, M., Stockhusen, C., Tantau, T.: On the space complexity of parameterized problems. In: International Symposium on Parameterized and Exact Computation. pp. 206–217. Springer (2012)
  • [22] Flum, J., Grohe, M.: Describing parameterized complexity classes. Information and Computation 187(2), 291–319 (2003)
  • [23] Ganian, R.: Improving vertex cover as a graph parameter. Discrete Mathematics & Theoretical Computer Science 17(2), 77–100 (2015)
  • [24] Grußien, B.: Capturing polynomial time using modular decomposition. In: 32nd Annual Symposium on Logic in Computer Science (LICS). pp. 1–12 (2017)
  • [25] Hopcroft, J.E., Wong, J.K.: Linear time algorithm for isomorphism of planar graphs (preliminary report). In: Proceedings of the sixth annual ACM symposium on Theory of computing. pp. 172–184. ACM (1974)
  • [26] Köbler, J., Kuhnert, S., Laubner, B., Verbitsky, O.: Interval graphs: Canonical representations in logspace. SIAM Journal on Computing 40(5), 1292–1315 (2011)
  • [27] Kratsch, S., Schweitzer, P.: Isomorphism for graphs of bounded feedback vertex set number. In: Algorithm Theory-SWAT 2010, pp. 81–92. Springer (2010)
  • [28] Lindell, S.: A logspace algorithm for tree canonization. In: Proceedings of the 24th annual ACM symposium on Theory of computing. pp. 400–404. ACM (1992)
  • [29] Lokshtanov, D., Pilipczuk, M., Pilipczuk, M., Saurabh, S.: Fixed-parameter tractable canonization and isomorphism test for graphs of bounded treewidth. SIAM Journal on Computing 46(1), 161–189 (2017)
  • [30] Luks, E.M.: Isomorphism of graphs of bounded valence can be tested in polynomial time. Journal of Computer and System Sciences 25(1), 42–65 (1982)
  • [31] Luks, E.M.: Parallel algorithms for permutation groups and graph isomorphism. In: Foundations of Computer Science, 27th Symposium on. pp. 292–302 (1986)
  • [32] Miller, G.: Isomorphism testing for graphs of bounded genus. In: Proceedings of annual ACM symposium on Theory of computing. pp. 225–235. ACM (1980)
  • [33] Otachi, Y.: Isomorphism for graphs of bounded connected-path-distance-width. In: ISAAC. pp. 455–464. Springer (2012)
  • [34] Stockhusen, C.: On the space and circuit complexity of parameterized problems. Ph.D. thesis, Dissertation, Lübeck, Universität zu Lübeck, 2017 (2017)
  • [35] Yamazaki, K., Bodlaender, H.L., de Fluiter, B., Thilikos, D.M.: Isomorphism for graphs of bounded distance width. Algorithmica 24(2), 105–127 (1999)
  • [36] Zemlyachenko, V., Konieko, N., Tyshkevich, R.: Graph isomorphism problem (russian). In: The Theory of Computation I, Notes Sci. Sem. LOMI 118 (1982)

7 Appendix

Proof of Theorem 5.1

Proof

The idea behind this proof is similar to that of Theorem 3.1. Let and be the two input graphs. The logspace graph isomorphism algorithm for graphs in works via finding a vertex deletion set for of size at most . Next we iterate over all vertex deletion sets of the same size. The idea is to fix an isomorphism from to and check if the isomorphism can be extended to an isomorphism of the input graphs. To store the vertex deletion sets we need space in the work-tape.

We first describe how to find a vertex deletion set of a graph . Choose a set of size at most vertices from and test whether by using the logspace algorithm (say ) for deciding if an input graph is in . For every set of size at most from , if the recognition algorithm says then algorithm can infer that . If for any of the sets, the algorithm says then algorithm outputs as vertex deletion set. The iteration of over sets of size at most can be easily implemented in logspace by using counters. Therefore, the whole process can be executed in logspace.

Let and be the vertex deletion sets of and obtained using the above logspace procedure. Fix a bijection from to and test if it is an isomorphism form to . If not we try the next in the lexicographic input order. Otherwise, we test if can be extended to an isomorphism of the input graphs. The map induces a coloring of the graphs and . Two vertices in () get same color if they have the same neighbourhood in ( respectively). A vertex in and a vertex in will get same color if . It is easy to see that the resulting graphs have at most colors. Moreover, can be extended to an isomorphism of and if and only if the colored versions of and are isomorphic.

Computing if two vertices and in have same color amounts to searching their neighbourhood in . Since is in the work-tape this can be done in logspace. Similarly, by the fact that and are in the work-tape, checking can also be performed in logspace. Since we can compute the colors in logspace, testing if colored and can be done in logspace using the logspace isomorphism test of colored graphs in . This completes the description of the algorithm.∎

Lemma 2

Let be a class of graphs characterized by finitely many forbidden induced subgraphs with for all where is a constant. There is a logspace algorithm that on input a graph decides if .

Proof

Given a graph , the aim is to check whether . For this it is enough to check for each whether contains as an induced subgraph. The algorithm heavily uses the input order of the vertices of . Let be the number of vertices in . To check if appears as an induced subgraph of , the algorithm picks vertices from and checks if these vertices induces in . If not then the algorithm chooses a different set of vertices according to the input order of and repeats the same process. For each , if none of the -sized subsets of forms then the algorithm concludes that . Otherwise it concludes that . It is easy to see that this algorithm can be implemented in logspace because at each step we need space to store at most vertices of and constantly many counters.∎