Actually, I wouldn't call what IGReorderVertices does relabelling. It really just changes the order in which vertices are stored. This in turn affects how certain functions work: the result of AdjacencyMatrix, the order in which BetweennessCentrality returns results, or what DirectedGraph[graph, "Acyclic"] does. It's more about changing the practical representation of the graph than doing anything of mathematical significance.

For true relabelling, you can use VertexReplace.

Example:

If we have

g = Graph[{1, 2, 3}, {1 <-> 2, 2 <-> 3}]

then

IGReorderVertices[{1, 3, 2}, g] returns the equivalent of

g = Graph[{1, 3, 2}, {1 <-> 2, 2 <-> 3}]

Note that the edge list has not changed. 2 is still the "middle" vertex.

VertexReplace[g, {1 -> 1, 2 -> 3, 3 -> 2}] return the equivalent of

g = Graph[{1, 3, 2}, {1 <-> 3, 3 <-> 2}]

Now the edge list has changed too, as 2 was renamed to 3 and 3 was renamed to 2.

If the relabelling is an isomorphic one, then of course the edge list doesn't change (by definition), except in its ordering. Thus, in this case, either function could be used.

In[19]:= perms = GroupElements@GraphAutomorphismGroup[g]
Out[19]= {Cycles[{}], Cycles[{{1, 3}}]}

We could do

VertexReplace[g, Thread[VertexList[g] -> Permute[VertexList[g], #]]] & /@ perms

or, keeping in mind that these re-labellings are isomorphic, simply use

IGReorderVertices[Permute[VertexList[g], #], g] & /@ perms

Hello Hector,

I originally started the IGraph/M package as a Mathematica interface to igraph, but since then it has gained several of these "little pieces" of code, which are often unrelated to igraph, and make it easier to work with graphs/networks in Mathematica.

In practice, these implementations of even trivial functions often end up being not so little due to the need to make them work fast and make them work on all sorts of graphs. The package is open source, so you can take a look at how things are done.

As for converting to undirected graphs, there's IGUndirectedGraph, which has three conversion modes: "Simple" does the same thing as the built-in UndirectedGraph: it uses a single undirected edge to connect vertices which have a directed edge between them. "All" creates an undirected edge for each directed one, and thus may create a multigraph. "Reciprocal" creates an undirected edge only when there are directed connections going both ways.

However, neither the built-in UndirectedGraph, not IGUndirectedGraph will preserve graph properties such as edge weights.

Thus there's IGWeightedUndirectedGraph, which preserves edge weights only (no other properties) and uses the specified function to combine weights of reciprocal edges (e.g. add them up).

As for permuting vertices, there's IGReorderVertices. It will preserve all graph properties.

To count automorphisms, you can use built-in functions: GroupOrder@GraphAutomorphismGroup[graph]. But IGraph/M also exposes the functionality of the Bliss library through IGBlissAutomorphismCount and other functions. I updated the Bliss library included in igraph to the latest version while working on this. For hard problems, Bliss will be much faster than Mathematica's built-ins. IGraph/M also has other isomorphism-related functionality that is not currently in Mathematica, such as finding subgraphs or considering edge and vertex colours.

IGraph/M is still under development, and contributions are very welcome. Such "little pieces of code" that are useful in everyday graph theory or network science work are one of the things I am looking for.