Non-rigid Molecular Symmetry Group

The non-rigid molecular symmetry group (NRMSG) is the automorphism group of the molecular graph. It is called non-rigid because molecules generally exhibit free rotation about the single bonds of their substructures [Lon62].

The NRMSG plays an important role in isomer counting, dynamic stereochemistry, atropisomerism, and a number of spectroscopic methods.

We have used a divide-and-conquer approach here, the first division being between cyclic and acyclic molecules. The former present significant difficulties for the structural representation that we are using, and thus will not be addressed here.

By restricting our analysis to acyclic molecules, whose molecular graphs are trees, we can take advantage of wreath products.

Graph Theory

A tree is either centric (single vertex centroid) or bicentric (two adjacent vertices centroid) [Har69].

Balancing a tree will root it at either the central vertex or pair of central vertices.

Examples

Group Theory

GroupTheory.m defines functions to construct and use groups. It is not restricted to any particular type of group element or combing operation. It uses the standard package DiscreteMath`Permutations.m for functions dealing with permutations.

Permutation Groups

We will use permutations to describe the interchange of atoms (sites) under the actions of the elements of the NRMSG.

Important groups

Group	sites	Symbol	Order
	n
	n
	n		n
	n
	4		12

Examples

We use the CircleTimes operator for group composition, which is associative (Flat). Conferring the attribute OneIdentity only applies to pattern matching, so we also supply a rule to reduce CircleTimes a --> a.

CircleTimes[a___, b_CircleTimes, c___] :=
    Flatten[Unevaluated[CircleTimes[a, b, c]], 1, CircleTimes]
CircleTimes[a_] := a

Wreath Products

Wreath products are hierarchical, or nested,  group compositions [Bal80]. Permutations within permutations, if you will.

The general form of a wreath product is , where is the outer group and is the inner group. is the composition of n , where n is the number of sites permuted by the outer group .

Depending on the analysis, the are either (symmetric group on n sites) or (cyclic group on n sites).

The wreath product is constructed directly from the molecule structure by recursively traversing the expression.

WreathProduct[mol_Molecule, space_] :=
    wreath[BalanceMolecule[mol], space]

wreath[Molecule[l:_[__], r:_[__]], Flat] :=
    With[{orbits = Map[wreath[#, Flat]&, Split[{l, r}], {2}]},
        Apply[Sn[##]&, orbits, 1] /. List->CircleTimes]
wreath[_[a_Symbol, lig:(_[__]...)], Flat] :=
    With[{orbits = Map[wreath[#, Flat]&, Split[{lig}], {2}]},
        Apply[Sn[a][##]&, orbits, 1] /. List->CircleTimes]
wreath[_[a_Symbol], Flat] := Sn[a]

Sn[a_Sn] := a
Sn[a_CircleTimes] := a

Example

We will use 2,2-bis(dimethylamino)-propane as our example. It has two 3-fold rotors, and two 2-fold rotors which have two 3-fold rotors within them, all arranged on a tetrahedral frame.

The wreath product is then used to construct the factor groups of the NRMSG for the space and sites specified.

permutationGroupFactors[mol_Molecule, space_Symbol, sites:{__Symbol}] :=
    Module[{n = 0, wp, g},
        wp = Switch[space,
            Flat,
                WreathProduct[mol, Flat] /. (#1 :> ++n & ) /@
                    sites /. Sn[_Symbol] -> Sequence[],
            Achiral,
                WreathProduct[mol, Achiral] /. (#1 :> ++n & ) /@
                    sites /. {(g_)[_Symbol] :> g,
                        Cn[_Symbol] -> Sequence[]},
            Chiral,
                WreathProduct[mol, Chiral] /. (#1 :> ++n & ) /@
                    sites /. {(g_)[_Symbol] :> g,
                        Cn[_Symbol] -> Sequence[]},
            ];
        DeleteCases[(ToFactorGroup[#1, n]&) /@
            Cases[wp, (Td|Dnh|Cnv|C2v|Cs|T|Dn|C2|Cn|Sn)[__],
                {0, Infinity}],
            {Range[n]}]]

Finally the factor groups are used to generate the full NRMSG.

NRMSG[mol_Molecule, space_Symbol] :=
    NRMSG[mol, space, {H}]
NRMSG[mol_Molecule, space_Symbol, sites:{__Symbol}] :=
    With[{gen=permutationGroupFactors[mol, space, sites]},
        Flatten[Outer[Permute, Sequence@@gen, 1], Length[gen]-1]
        ]

And, for our example above: