Classical algorithms

As mentioned above, GIseems to be hard because the space Sn of potential solutions is

so large. It is not so surprising, then, that when this space can be reduced substantially, the problem becomes tractable. Polynomial-time algorithms are known for several types of graphs in which some graph invariant allows this search space to be reduced: Graphs with bounded degree [77] (thedegreeof a vertexv is the number of edges incident onv), graphs with bounded eigenvalue degeneracy [10] (theeigenvaluesof an undirected graph are the (real) eigenvalues of its adjacency matrix), and graphs with bounded genus [48, 80] (thegenusof a graph is that of the minimum-genus orientable surface on which the graph

may be embedded with no edge crossings; for the particular case of planar graphs, a more readable algorithm is in Kuˇcera [68]) all have polynomial-time isomorphism algorithms. (Typically the time bound for such results is of the formO(nax+b), wherexis the bounded quantity andaand b are constants.)

A simple instructive example is the algorithm for TreeGI where the graphs are re- stricted to be trees(connected acyclic graphs). The algorithm is as follows:

BEGINwith an unlabeled tree.

Give each leaf (vertex of degree 1) the label 1.

whilethe tree contains unlabeled vertices do

for each unlabeled vertexv adjacent to a vertex labeled in a previous iteration, attach the label{`e}, the set of all

labels of labeled vertices adjacent tov.

ENDwith a labeled tree; the list of labels, sorted lexicographically, is a faithful invariant for the tree.

To determine whether two trees are isomorphic, one computes each tree’s lexicographi- cally-sorted list of labels and compares them. If the two lists are identical, the trees are isomorphic; if the lists differ, the trees are not isomorphic.4

This example illustrates an important concept in isomorphism problems, also men- tioned in passing above: the idea of invariants. We now formalize this concept, since it will be useful in later discussion. A function r(x) : X → R (where the domain X is the

presentation space, on which the isomorphism ∼ is defined, and the range R is the

representation space) is aninvariant, or a canonicalrepresentation, if it is constant on equivalence classes of X: i.e., r(x) = r(y) if x ∼ y. An invariant is complete, or

faithful, if it is constant only on equivalence classes of X: i.e., r(x) = r(y) iff x ∼ y. A faithful invariant (often called a certificate) preserves all the information about an object’s equivalence class, and so an efficient method of finding faithful invariants allows 4_{This algorithm may be improved somewhat, if all we care about is whether G∼H, by noting that}

the lexicographically-sorted lists must agreeat each stage of labeling; so we may compare the partial lists after each iteration of thewhileloop, returningnot isomorphicif the lists ever differ. The algorithm is presented as shown to give an example of an invariant for a graph.

a solution to the isomorphism problem. In the example above, the set of labels for the completely-labelled tree is just such a faithful invariant. Unfortunately, nodeterministic

(polynomial-time computable) certificateris known for a general graph ([31], for example, computes a certificate in exponential, but subfactorial, time). Succinct(polynomial-size) certificatesare known: e.g., first{H:H ∼G}, where firstX gives the element ofX which is lexicographically minimal.5 Unfortunately, succinct certificates for graphs seem to be difficult to compute in general.

Note that a general isomorphism problem reduces polynomially to the problem of finding succinct certificates, but that these two problems are not necessarily equivalent: it may be easier to determine whether two objects are isomorphic than to find a succinct certificate for an object. It may, however, be more useful to find a succinct certificate. For instance, consider the application of finding a match to a previously-classified graph in a database of N graphs. If we only have an algorithm to solve the decision-problem version of GIfor a graph, we must apply it on average O(N) times to the graphs in the database (we cannot sort the database, since we don’t have a useful ordering function) to find a match. On the other hand, if we have an algorithm to find a succinct certificate for a graph, we can apply it once to find a certificateGfor the unknown graph, and then compare (in average time O(|G|logN)) the certificate to the certificates in the database (which is sorted, of course, on the certificate). Thus for large databases, finding succinct certificates is more useful than merely determining whether two graphs are isomorphic.

It is important, in considering the quantum case, to examine carefully what is needed for this method to work. The definition of an invariant needs no modification for the quantum case, but we must decide what we mean by a quantum certificate: Let us call a quantum representation (i.e., a representation by elements of a Hilbert space) faithful

if distinct objects map to orthogonal states6,hr(x)|r(y)i= 0 if x 6∼ y. In the classical case, of course, it is easy to compare the two certificates, and they may be copied at

5

It is easy to see that in fact all problems inPhave deterministic certificates, and all problems in NP

have succinct certificates.

6

This restriction, at least, seems necessary to preserve the idea of a faithful representation; otherwise one cannot perfectly distinguish different certificates. Further restrictions on the allowable classes of basis states may also be useful to consider.

will; so the comparison routine is perfect andinformation-preserving. But if we have two quantum certificates, neither of these conditions necessarily holds: I know of no efficient ways to implement either a perfect comparison routine or a perfect copier for states chosen from an arbitrary (but known) orthogonal set, so a database of quantum certificates is more difficult to use than a database of classical certificates.7 Thus, it seems that generic quantum certificates have less power than classical certificates.