Here - Combinatorial algorithms and algorithmic graph theory

32 Generation of cubic graphs
the mapping φ ′ from V (T (G, S ′ )) to V (G) similarly. The permutation γ 0 of V (G)
defined by γ 0 (φ(v)) = φ ′ (γ(v)) for all v ∈ V (T (G, S)) is an automorphism of G.
Moreover, γ 0 maps S onto S ′ with the possible exception that when S contains
one extremal vertex w, and no other vertex, of a K4
− subgraph H, S ′ might
contain either γ 0 (w) or the other extremal vertex of the K4
− subgraph γ 0(H). In
either case, S ≡ S ′ by the definition of equivalence.
Since for every graph with reducible triangles the graph resulting from a
bundled triangle reduction is uniquely determined (i.e. every graph obtained by
a bundled triangle insertion operation is canonical), we get the following Lemma:
Lemma 2.5. If exactly one representative of every isomorphism class of cubic
connected graphs up to n − 2 vertices is given, then applying bundled triangle
insertion to one member of each equivalence class of extensible sets that leads
to a cubic connected graph on n vertices generates exactly one representative for
every isomorphism class of cubic connected graphs on n vertices that contain
reducible triangles.
Thus no isomorphism rejection is needed for graphs with reducible triangles
(other than the equivalence relation on extensible sets): graphs constructed by
the bundled triangle operation are always canonical and pairwise non-isomorphic.
This is one of the main advantages of the triangle insertion bundling, as checking
whether the last operation was canonical can be very expensive in general. This
does not only avoid the time for canonicity checking, but also the time needed
for constructing graphs that are rejected after construction because they are not
canonical. Also note that graphs with r reducible triangles and n vertices are
generated from graphs with n − 2r vertices. So as can be seen from Table 2.2 at
the beginning of this section, graphs with reducible triangles are often generated
from much smaller graphs.
2.4.3 Optimisations
One of the routines that can be time consuming in structure generation programs
is the computation of automorphism groups. We used nauty for this task.
Although nauty is very efficient, the large number of calls can be expensive.
The argument used in the proof of Lemma 2.4 shows that a non-trivial automorphism
of T (G, S) must come from a non-trivial automorphism of G. So if
Aut(G) is trivial, this implies that Aut(T (G, S)) is also trivial. Thus if Aut(G)
is trivial, we do not have to call nauty to compute Aut(T (G, S)). This is another