# Symmetry (and Basis Changes)

Symmetry in crystalline systems can be a little confusing, so herewith some notes on aspects which have, in the past, confused me.

A symmetry operation consists of a rotation matrix followed by the addition of a translation vector. If the vector q is the result of applying a symmetry operation S to the vector p, then q=Rp+t, where R is a rotation matrix and t a translation vector. Permitted rotation matrices include "improper" rotations, that is a rotation combined with an inversion through the origin. The axis will be one-, two-, three-, four- or six-fold.

Suppose one has a pure rotation axis about a point other than the origin. Suppose the axis passes through the point u. Then operating this symmetry operation on a point p gives q=R(p-u)+u. In other words one shifts the co-ordinates so that u is at the origin, applies a normal rotation matrix, and shifts back. Expressed in the more conventional form, this is q=Rp+(1-R)u. So the translation part of the symmetry operator is not u, but t=(1-R)u. One can then write u=(1-R)-1t, but beware that R, a rotation matrix, has an eigenvalue of one (the rotation axis), so (1-R) has an eigenvalue of zero.

The symmetry of a crystal is a fundamental property of the crystal which is independent of how the crystal is described. The usual description of a lattice and symmetry operations within a unit cell leaves the lattice to describe the translational symmetry, and then operations within the cell to describe rotations. There can be at most 48 symmetry operations within the cell.

But if the cell is actually a supercell of the primitive cell, it will contain pure translations amongst its symmetry operations. This makes the maximum number of operations unbounded -- it is 48 times the ratio of the supercell volume to the primitive cell's volume.

Convention says that one always uses primitive cells, except for base, face and body centred systems, when one may use the supercell which has the extra centrering points. This gives a maximum number of symmetry operations of 192 as a face-centred cell has four times the volume of its primitive cell.

Note that all operations are listed, so a six-fold axis will be listed as two six-fold operations (rotations by one sixth and five-sixths of 2π), two three-fold operations (two- and four-sixths), one two-fold, and the identity.

## Symmetry after Basis Changes

The following issues arise after a change of basis.

• Is the orientational relationship between the old and new bases known? If not, preserving symmetry operations is impossible.
• Are the rotational parts of the symmetry operations consistent with the new lattice? Most DFT codes require that they map lattice points to lattice points. In 2D, a 2x1 supercell of a square would no longer have a four-fold axis.
• After removing operations inconsistent with the new lattice, do the remaining operations form a consistent set? That is, does every symmetry operation have an inverse, and is the product of any two operations also a symmetry operation?

Prior to version 2.40d, c2x discarded symmetry operations after almost all changes of basis. Assuming that c2x had been built with SPGlib, one could always recalculate them.

From version 2.40d, c2x makes a greater attempt to retain symmetry operations. One can revert to the old behaviour by specifying `-n` to discard the symmetry operations explicitly.

In version 2.40d, it has two independent settings which govern how symmetry operations are treated after a transformation.

By default extra translation operations are not added, but if a `-x=` or `-X=` operation is specified as `-xs=` or `-Xs=`, then the translation operations arising from the old basis will be added.

Adding extra translations is not the default as, when constructing large supercells, one can end up with many more symmetry operations than most DFT codes can read. Translations are anyway less interesting, as they do not map k-points into each other.

When checking the symmetry operations for consistency, one can either add operations which appear to be missing, or remove operations to try to make the resulting set consistent. By default c2x 2.40d will remove operations. This is partly because this is a new feature, and I am more confident of converging to a consistent set by removing operations than I am by adding! If one wishes to specify a particularly behaviour, then the options are `--sym_add` and `--sym_del`.

## Examples

(C2x 2.40d or later is needed for these examples.)

### Diamond

Starting from the primitive diamond cell,

```%BLOCK LATTICE_CART
0.00  1.78 1.78
1.78  0.00 1.78
1.78  1.78 0.00
%ENDBLOCK  LATTICE_CART

%block POSITIONS_FRAC
Si 0.0     0.0     0.0
Si 0.25    0.25    0.25
%endblock POSITIONS_FRAC
```

one can use SPGlib to add the symmetry operations

```\$ c2x --sym --cell diamond2.cell diamond2_sym.cell
Tol=0.0001  48 symmetry operations found.
```

This can then be converted to the face-centred cubic cell

```\$ c2x -x='(-1,1,1)(1,-1,1)(1,1,-1)' --cell -v diamond2_sym.cell new.cell
```

This results in a cell with just 24 symmetry operations, for the screw axes and glide planes now lack inverses in the larger cell. Even the inversion point is lost, for the product of the inversion point and the 2 axis through the origin is a glide plane which no longer exists.

Determining which operations to drop in order to create a consistent set is a little arbitrary. Some will argue that an inversion point is such a defining characteristic of a crystal that it should be the last to be dropped. Others that symmetry is usually most important in k-space which has inversion symmetry anyway, so a real space inversion point is the least important.

```\$ c2x -x='(-1,1,1)(1,-1,1)(1,1,-1)' --cell --sym_add -v diamond2_sym.cell new.cell
```

Now when an operation is missing, it is added. The full set of 192 symmetry operations expected for diamond in an fcc cell result.

A better way of achieving the same result is to ask c2x to add the translation vectors from the old lattice to the symmetry operations in the new cell. This is achieved by adding an "s" after the "x".

```\$ c2x -xs='(-1,1,1)(1,-1,1)(1,1,-1)' --cell -v diamond2_sym.cell new2.cell
```

This also produces 192 symmetry operations. These last two files are the same, but they do not look it as they list the symmetry operations in different orders. It is hard to sort symmetry operations well as the translation part may well be store inexactly. Adding the undocumented `-Q4` option to c2x partially sorts the operations, but the files still do not look identical. To prove that they are, first run

```\$ sed -i 's/-0\.00/ 0.00/g' new.cell
\$ sed -i 's/-0\.00/ 0.00/g' new2.cell
```

to remove all occurances of -0.000000 in favour of 0.00000. Then simply sort each file to produce a jumbled output, but the jumbling should be the same in both cases.

```\$ LC_ALL=C sort < new.cell > n
\$ LC_ALL=C sort < new2.cell > n2
\$ diff n n2
\$
```

### Cubic Silicon Carbide

```%block LATTICE_CART
ang
0.00   2.18   2.18
2.18   0.00   2.18
2.18   2.18   0.00
%endblock LATTICE_CART

%block POSITIONS_FRAC
Si 0.00  0.00  0.00
C  0.25  0.25  0.25
%endblock POSITIONS_FRAC
```

This structure is very similar, but it lacks the inversion point of diamond. So the primitive cell has just 24 symmetry operations, rather than the 48 of diamond in which each of these 24 is combined with the inversion point.

Every symmetry operation has a zero translational part. This means that the set is still consistent after forming the supercell. So here `-x='(-1,1,1)(1,-1,1)(1,1,-1)'` results in 24 symmetry operations regardless of whether `--sym_add` or `--sym_del` is specified.

To generate the full set for the cubic fcc cell, one must use the `-xs` option, which then produces 96 symmetry operations.