APS March Meeting 2026 Tutorial

APS March Meeting 2026 — GDS Short Course on Data Science for Physicists II

Speaker: Tess Smidt, MIT | Short link: tinyurl.com/aps-2026-tutorial-tess

1) Motivation

Symmetry is one of the most powerful organizing principles in science. In physics and chemistry, it determines which transitions are allowed, how orbitals split in a crystal, and what the normal modes of a molecule look like. In machine learning, building symmetry into a model's architecture can dramatically reduce the number of parameters and the amount of training data needed.

But the mathematical language for symmetry — representation theory — can feel like a separate subject with its own specialized vocabulary: irreducible representations, Clebsch-Gordan coefficients, Schur's lemma, character tables. The goal of this tutorial is to show that nearly all of it reduces to one equation you already know from linear algebra: the similarity transform.

S and R are matrix representations of a group G, and Q is the change-of-basis matrix we want to find. When S and R are group representations, Q is called an intertwiner — but the equation itself is just a similarity transform, and the method for solving it is pure linear algebra. By finding the nullspace of a matrix, this single equation gives you:

• All irreducible representations of finite groups and compact Lie groups*
• Vibrational mode decomposition of molecules
• Spherical harmonics and Clebsch-Gordan coefficients from scratch
• Crystal field splitting of atomic orbitals
• The allowed weight matrices in equivariant neural networks

*For non-compact groups (e.g. the Lorentz group), the unitary irreps are typically infinite-dimensional and require more machinery — but the same principle applies.

If you know linear algebra, you already know representation theory.

2) Outline

This tutorial builds up from basic group theory to equivariant machine learning in five acts:

• Crash Course — What are groups, representations, and irreps? (Using the symmetries of a triangle as a running example.)
• Act 1 — The similarity transform equation QS = RQ and how to solve it via the Kronecker product trick and nullspace computation.
• Act 2 — Applying QS = RQ to finite groups: finding all irreps from the regular representation, and decomposing the vibrational modes of water.
• Interlude — The three fundamental operations for building representations: direct sum, tensor product, and change of basis.
• Act 3 — Extending to continuous groups (Lie groups): SO(3) generators, spherical harmonics, Clebsch-Gordan coefficients, parity, and crystal field theory.
• Act 4 — Equivariant machine learning: how symmetry constrains neural network weights, and why one architecture handles all symmetries.
• Act 5 — The unifying picture: one equation, many applications.

3) Tutorial Materials

The rest of this page provides a deeper mathematical treatment of each topic covered in the tutorial, with cross-references to the full course notes.

4) Crash Course: Groups and Representations

If you are already comfortable with groups, representations, and irreps, skip ahead to Act 1. Otherwise, here is what you need to know, illustrated with the symmetries of an equilateral triangle. (For the full treatment, see the groups and representations course notes.)

4.1) What is a Group?

A group is a set of elements with a way to combine them (a "multiplication") that satisfies four rules: closure (combining two elements gives another element), associativity, an identity element, and inverses for every element.

The symmetries of an equilateral triangle (and equivalently, the permutations of three objects) form a group called P(3) (also written S_3 or D_3). It has 6 elements: the identity E, three mirror reflections A, B, C, and two rotations D (120°) and F (240°).

The multiplication table records every possible composition. Click any cell below to see the composition as an action on the triangle:

Notice that the table is not symmetric — AB \neq BA. This makes P(3) a non-abelian group.

4.2) What is a Representation?

A representation is a way to "write down" each group element as a matrix acting on a vector space, such that matrix multiplication mirrors group multiplication:

The same group can have many different representations — different sets of matrices acting on different vector spaces. For P(3), we can represent each element as a 3 \times 3 permutation matrix (acting on 3 objects) or as a 2 \times 2 rotation/reflection matrix (acting on the plane). Click through the elements below to see both:

Representations are not unique — if D(g) is a representation and U is any invertible matrix, then U \, D(g) \, U^{-1} is also a valid representation. This is just a change of basis (similarity transform).

4.3) Irreducible Representations (Irreps)

Some representations can be decomposed into independent blocks. If you can find a basis (a change of basis U) such that U \, D(g) \, U^{-1} is block diagonal for all group elements simultaneously, the representation is reducible. If no such basis exists, the representation is irreducible — an irrep.

Irreps are the fundamental building blocks: any representation can be decomposed into a direct sum of irreps, just as any integer can be factored into primes.

P(3) has exactly three irreps:

• \Gamma_1 (dim 1) — the trivial irrep: every element maps to 1
• \Gamma_1' (dim 1) — the sign irrep: rotations \to 1, mirrors \to -1
• \Gamma_2 (dim 2) — the standard irrep: the 2 \times 2 rotation/reflection matrices

A fundamental fact: the sum of squared dimensions equals the group order: 1^2 + 1^2 + 2^2 = 6 = |P(3)|.

5) Act 1: The Similarity Transform

5.1) The Equation

Given two representations S(g) and R(g) of the same group, we want to find all change-of-basis matrices Q satisfying

This is a similarity transform: S and R are the same linear transformation written in different bases, and Q is the change of basis between them. Rearranging, each group element gives a constraint:

5.2) The Kronecker Product Trick

How do we solve SQ - QR = 0 computationally? The unknown Q appears on both sides, multiplied by different matrices — this isn't a standard Ax = b problem. The trick is to use the Kronecker product to convert it into one.

Write the (i,k) component of SQ - QR = 0 in index notation:

Here's the key insight: in index notation, S_{ij}, Q_{jk}, and R_{\ell k} are just numbers (scalars). Scalars commute, so we can rearrange them freely — unlike matrix multiplication where SQ \neq QS in general.

The problem is that the two terms sum over different indices of Q: the first sums over j (the row index), while the second sums over \ell (the column index). We want to write both terms as sums over the same pair of indices (j, \ell) so we can factor out Q_{j\ell}. We do this by inserting Kronecker deltas (\delta_{ab} = 1 if a = b, 0 otherwise):

This works because the \delta_{k\ell} forces \ell = k, collapsing the sum over \ell and recovering the original expression. Similarly:

where \delta_{ij} forces j = i. Now both terms are sums over (j, \ell) with a common factor of Q_{j\ell}, so we can combine them:

This equation says: the 4-index object P_{ik,j\ell} = S_{ij} \, \delta_{k\ell} - \delta_{ij} \, R_{\ell k} acts on the 2-index object Q_{j\ell}. If we flatten both into vectors/matrices (stacking (i,k) into a single row index and (j,\ell) into a single column index), this becomes a standard matrix-times-vector equation: P \, \text{vec}(Q) = 0.

But what matrix is P? To see, we need the Kronecker product.

5.3) The Kronecker Product

The Kronecker product (or tensor product) of matrices A (m \times n) and B (p \times q) is the mp \times nq block matrix formed by replacing each entry A_{ij} with the block A_{ij} B:

In index notation: (A \overset{\text{kr}}{\otimes} B)_{ik,j\ell} = A_{ij} \, B_{k\ell}, where the pairs (i,k) and (j,\ell) are each flattened into single indices.

Two special cases are important for us:

• A \overset{\text{kr}}{\otimes} \mathbb{I} has entries (A \overset{\text{kr}}{\otimes} \mathbb{I})_{ik,j\ell} = A_{ij} \, \delta_{k\ell} — exactly the structure of our first term!
• \mathbb{I} \overset{\text{kr}}{\otimes} B has entries (\mathbb{I} \overset{\text{kr}}{\otimes} B)_{ik,j\ell} = \delta_{ij} \, B_{k\ell} — exactly the structure of our second term (with B = R^T, since R_{\ell k} = (R^T)_{k\ell}).

So our constraint matrix P is:

and the solutions for Q are the nullspace of P. We have converted the matrix equation SQ = QR into a standard nullspace problem!

The interactive visualization below walks through the full index manipulation:

(See also the linear algebra notes for further detail on Kronecker products and sums.)

For group representations, we need a single Q that works for all group elements g simultaneously: S(g) Q = Q R(g) for all g \in G. We simply stack the constraint matrices:

and the solutions are \ker(P_\text{all}). More group elements means more constraints, which narrows the solution space. For continuous (Lie) groups, we stack constraints from the finitely many generators instead.

5.4) What the Solution Space Tells You

The dimension of \ker(P_\text{all}) — i.e. the number of independent Q matrices solving SQ = QR — is extraordinarily informative:

The remarkable thing is that all of representation theory — finding irreps, decomposing representations, computing Clebsch-Gordan coefficients, constraining equivariant maps — comes from solving P_\text{all} \, \text{vec}(Q) = 0 with different choices of S and R.

6) Act 2: Irreps from Scratch

6.1) The Regular Representation

The regular representation is a representation of dimension \lvert G \rvert built directly from the group's multiplication table. For each group element g, the matrix D_{\text{reg}}(g) permutes basis vectors according to left multiplication: D_{\text{reg}}(g) \, \mathbf{e}_h = \mathbf{e}_{gh}. Each row of the multiplication table directly encodes one of these permutation matrices:

A fundamental theorem states that the regular representation contains every irrep of the group, each appearing a number of times equal to its dimension:

where \ell_j = \dim(\Gamma_j). This means \sum_j \ell_j^2 = \lvert G \rvert. So the irreps are in there — we just need to extract them.

6.2) Extracting Irreps via QS = RQ

The decomposition algorithm works as follows:

1. Self-similarity: Set S = R = D_{\text{reg}} and solve for all Q such that D_\text{reg}(g) \, Q = Q \, D_\text{reg}(g) for all g.

2. Random combination: The solution space has dimension \sum_j \ell_j^2. Take a random linear combination of the basis solutions to get a single matrix Q_\text{rand}.

3. Eigendecompose: The eigenspaces of Q_\text{rand} are (generically) the irreducible subspaces! Each distinct eigenvalue corresponds to one copy of one irrep.

4. Project: Extract the irrep matrices by projecting D_\text{reg} onto each eigenspace.

Example — S_3 (the symmetric group on 3 elements):

S_3 has order 6, so D_\text{reg} is 6 \times 6. The solution space (the commutant) has dimension 1^2 + 1^2 + 2^2 = 6. A random Q from this space has eigenvalues falling into three groups: a 1D eigenspace (the trivial irrep \Gamma_1), another 1D eigenspace (the sign irrep \Gamma_2), and a 2D eigenspace (the standard irrep \Gamma_3).

We put in only the multiplication table. We got out all irreducible representations.

The interactive graphic below walks through each step of the decomposition algorithm:

6.3) Molecular Vibrations — Water

The same equation decomposes vibrational modes. For a molecule with N atoms and point group symmetry G:

Step 1: Build the displacement representation. Each symmetry operation does two things: it permutes atoms and rotates their displacement vectors from equilibrium. The permutation representation D_\text{perm}(g) (N \times N matrices) records which atoms go where under each symmetry operation. The vector representation D_\text{vec}(g) (3 \times 3 matrices) records how 3D coordinates transform. The full displacement representation is their tensor product:

For water (C_{2v}, N = 3), this gives 3 \times 3 = 9-dimensional matrices. The graphic below shows how the permutation representation is constructed from the molecular geometry, and how the tensor product combines the two:

Step 2: Project out translations and rotations. The 3 translations and 3 rotations each transform as specific irreps of G. We construct a vibrational projector P^\text{vib} = I - P^\text{trans} - P^\text{rot} and use it to extract a basis Q for the vibrational subspace (3N - 6 dimensions, or 3N - 5 for linear molecules).

Step 3: Build the vibrational representation. Apply the projector to the displacement representation: D_\text{vib}(g) = Q^T \, D_\text{disp}(g) \, Q. This gives compact (3N-6) \times (3N-6) matrices — the group action restricted to the vibrational subspace.

Step 4: Decompose into irreps using QS = RQ. Each irrep subspace corresponds to a normal mode or set of degenerate normal modes.

For water (n = 3), removing translation and rotation from the 9D displacement space leaves 3 vibrational modes: two A_1 modes (symmetric stretch and bend) and one B_1 mode (asymmetric stretch). The interactive graphic below shows the full decomposition — click through the subspaces to see how the 9D space splits into translation, rotation, and vibration:

The irrep label of each mode tells you the selection rules: which modes are detectable by which type of spectroscopy. The key is the character table, which lists the basis functions for each irrep:

• IR active if the irrep appears among the linear functions (x, y, z) — these correspond to changes in dipole moment.
• Raman active if the irrep appears among the quadratic functions — these correspond to changes in polarizability.

Since A_1 contains z (linear) and x^2, y^2, z^2 (quadratic), and B_1 contains x (linear) and xz (quadratic), all three vibrational modes of water are both IR and Raman active.

See the full vibrational modes notes for a deeper treatment of selection rules and spectroscopy.

7) Interlude: Building New Representations

Before moving to continuous groups, it is worth noting that there are three fundamental operations for building new representations from existing ones — and we have already seen all of them:

• Direct sum (\oplus): Stack representations into block-diagonal form. The direct sum of an m-dimensional and an n-dimensional representation gives an (m + n)-dimensional representation. This is how we decompose representations into irreps.

• Tensor product (\otimes): Given two representations D^{(1)}(g) and D^{(2)}(g) of the same group, their tensor product is defined element-wise using the Kronecker product: D^{(1 \otimes 2)}(g) = D^{(1)}(g) \overset{\text{kr}}{\otimes} D^{(2)}(g). This gives a new, typically larger representation (dimension m \times n) that can then be decomposed into irreps. We already used this to build the displacement representation D_\text{perm} \otimes D_\text{vec} for vibrational modes.

• Change of basis (similarity transform): D'(g) = Q \, D(g) \, Q^{-1}. This gives an equivalent representation in a different basis — and finding the right Q is exactly QS = RQ.

These three operations — together with the nullspace method for finding Q — are all we need. The remarkable thing is that the same operations, applied to generators instead of group elements, carry over directly to continuous groups. (For the full treatment of tensor products and decomposition, see the decomposition and products notes.)

8) Act 3: Continuous Groups and SO(3)

8.1) From Finite Groups to Lie Groups

Everything so far has used finite groups, where we can enumerate every element. Continuous groups (Lie groups) like SO(3) — the group of all rotations in 3D — have infinitely many elements. But they are built from infinitesimal operations called generators: small rotations, small translations, etc. Any group element can be reached by exponentiating a combination of generators:

where X_k are the generators (elements of the Lie algebra) and \vec\theta are continuous parameters. The matrix exponential is defined exactly like the scalar exponential, via its Taylor series:

So "exponentiating a generator" just means plugging a matrix into this power series. For a small parameter \epsilon, the first-order term dominates: e^{i\epsilon X} \approx I + i\epsilon X. This is why generators describe infinitesimal transformations — X is the "direction" of the transformation, and \theta is "how far" you go. The full exponential e^{i\theta X} builds up a finite transformation by composing infinitely many infinitesimal steps.

The representation matrices follow the same pattern: D(g(\vec\theta)) = e^{i \sum_k \theta_k D(X_k)}.

The key insight is that a change of basis on group elements is identical to a change of basis on generators: U \, e^X \, U^{-1} = e^{U X U^{-1}}. So if Q satisfies S(g) Q = Q R(g) for all group elements, it also satisfies

and vice versa. This means all of our code and intuition carries over unchanged — we build P_\text{all} by stacking constraints for the (finitely many) generators instead of all group elements. The same is true for the other operations: direct sums of generators give direct sums of representations, and tensor products of representations correspond to Kronecker sums of generators (X \overset{\text{kr}}{\oplus} Y = X \otimes I + I \otimes Y). The nullspace computation works identically. (See the Lie groups notes for the full derivation of each operation.)

8.2) SO(n) — Rotation Groups

The rotation group SO(n) consists of all n \times n orthogonal matrices with determinant 1: R^T R = I, \det R = 1. What do the generators look like? A rotation matrix near the identity is R = e^{i\epsilon X} \approx I + i\epsilon X. For this to satisfy orthogonality (R^T R = I) to first order:

This requires X^T + X = 0, i.e. X^T = -X. So the generators of SO(n) (in the vector representation) must be antisymmetric matrices. The diagonal entries are forced to be 0, and each upper-triangle entry determines the lower-triangle entry with a sign flip — giving n(n-1)/2 independent generators.

For SO(3) — rotations in 3D — there are 3(3-1)/2 = 3 generators, conventionally called L_x, L_y, L_z (the angular momentum operators from quantum mechanics). These satisfy the commutation relations:

where [A, B] = AB - BA is the commutator and \epsilon_{ijk} is the Levi-Civita symbol: \epsilon_{ijk} = +1 for even permutations of (x,y,z), -1 for odd permutations, and 0 if any two indices are equal. Written out explicitly: [L_x, L_y] = i L_z, [L_y, L_z] = i L_x, [L_z, L_x] = i L_y. These commutation relations define the Lie algebra \mathfrak{so}(3) — they are the same in every representation, even though the explicit matrices change.

8.3) Building All Irreps from Tensor Products

Starting from the vector representation (l = 1), we can discover all irreps of SO(3) through recursive tensor products.

Take the tensor product of the 3D vector representation with itself to get a 9D representation. Decompose with QS = RQ:

Out come three irreps: the scalar (l = 0, dim 1), vector (l = 1, dim 3), and symmetric traceless tensor (l = 2, dim 5). Now iterate — tensor each new irrep with l = 1 and decompose again:

Each step discovers one new irrep. In general, the tensor product of SO(3) irreps follows the triangle rule (also called the Clebsch-Gordan series):

The l-th irrep has dimension 2l + 1. The Casimir operator L^2 = L_x^2 + L_y^2 + L_z^2 acts as -l(l+1) \cdot I on the l-th irrep, providing a convenient label.

8.4) Clebsch-Gordan Coefficients

The Clebsch-Gordan (CG) coefficients are exactly the Q matrices (intertwiners) from the similarity transform equation applied to tensor product decomposition:

Here S = D^{(l_1)} \otimes D^{(l_2)} is the tensor product representation and R = D^{(l_3)} is an irrep appearing in the decomposition. The solution Q (of shape (2l_1+1)(2l_2+1) \times (2l_3+1)) is a CG matrix.

Every Clebsch-Gordan table you have ever looked up is a solution to this equation. But the solution is not unique — any unitary rotation within a degenerate subspace gives an equally valid set of CG coefficients. This is why there are so many different conventions across physics, chemistry, and materials science, and why converting between them (itself a change of basis!) is a perennial headache.

8.5) Spherical Harmonics

The spherical harmonics Y_l^m(\theta, \phi) are the lowest-order polynomials of (x, y, z) that transform as irreps of SO(3). Specifically, the 2l + 1 spherical harmonics of degree l are a set of homogeneous polynomials of degree l in (x, y, z), restricted to the unit sphere, that form a basis for the l-th irrep:

• l = 0: the constant 1 (degree 0) — a scalar
• l = 1: the three linear functions \{x, y, z\} (degree 1) — a vector
• l = 2: five quadratic combinations like xy, xz, yz, x^2 - y^2, 2z^2 - x^2 - y^2 (degree 2)
• l = 3: seven cubic polynomials (degree 3), and so on

They can be constructed recursively using tensor products and CG coefficients:

1. Start with the l = 1 basis: \{x, y, z\}
2. Take the tensor product l = 1 \otimes l = 1 and extract the l = 2 component using the CG coefficients
3. Continue: l = 2 \otimes l = 1 \to l = 3, and so on

At each step, the CG coefficients (solutions to QS = RQ) tell you how to combine lower-order harmonics into higher-order ones. There is no lower-degree polynomial basis that transforms as the l-th irrep — the spherical harmonics are the simplest polynomial functions with each rotational symmetry.

Spherical harmonics show up throughout physics precisely because they are the angular eigenfunctions of the Laplacian in spherical coordinates. In quantum mechanics, the hydrogen atom wavefunctions separate into a radial part R_{nl}(r) and an angular part Y_l^m(\theta, \phi). The quantum number l labels the SO(3) irrep, giving us the familiar atomic orbital naming: l = 0 are s-orbitals, l = 1 are p-orbitals, l = 2 are d-orbitals, l = 3 are f-orbitals. In a free atom (full SO(3) symmetry), all 2l + 1 orbitals within a given l are degenerate. When the atom is placed in a lower-symmetry environment — a crystal, a molecule, an external field — this degeneracy can be broken, which is exactly the crystal field splitting we discuss below.

8.6) Parity and O(3)

SO(3) contains only proper rotations (\det R = +1). The full orthogonal group O(3) also includes inversion (\mathbf{r} \to -\mathbf{r}) and improper rotations (rotation composed with inversion). Adding inversion doubles the group: O(3) = SO(3) \times \{I, -I\}.

Under inversion, the irreps of SO(3) split into two types based on parity p = \pm 1:

• Even parity (p = +1): unchanged under inversion. Examples: scalars, d-orbitals, even-l spherical harmonics.
• Odd parity (p = -1): pick up a sign flip under inversion. Examples: vectors (l = 1), f-orbitals, odd-l spherical harmonics.

For spherical harmonics built recursively from tensor products of l = 1, the parity follows from the degree: p = (-1)^l. This is because each tensor product with l = 1 (which is odd) flips the parity.

The distinction matters physically: the cross product of two vectors (l = 1 \otimes l = 1 \to l = 1) produces a pseudovector — it transforms like l = 1 under rotations but is even under inversion (parity +1), unlike a true vector (parity -1). Angular momentum \mathbf{L} = \mathbf{r} \times \mathbf{p} and the magnetic field \mathbf{B} are pseudovectors.

In equivariant neural networks for atomistic simulation, irreps of O(3) are labeled by both l and p: e.g. (l{=}1, p{=}{-}1) for vectors and (l{=}1, p{=}{+}1) for pseudovectors. Keeping track of parity ensures the model correctly handles reflections and inversion.

8.7) Crystal Field Theory

Crystal field splitting is a direct application of QS = RQ — now as a branching (or subduction) problem: what happens to an SO(3) irrep when the symmetry is lowered to a finite subgroup?

Consider an atom in an octahedral crystal environment (point group O_h). The d-orbitals transform as the l = 2 irrep of SO(3) (dimension 5). But O_h is a subgroup of SO(3), so the l = 2 representation, when restricted to O_h operations only, may no longer be irreducible.

To decompose: take S = R = D^{(l=2)} restricted to O_h elements, solve QS = RQ, and examine the eigenspaces of Q:

• A 3-dimensional eigenspace: the t_{2g} orbitals (d_{xy}, d_{xz}, d_{yz})
• A 2-dimensional eigenspace: the e_g orbitals (d_{z^2}, d_{x^2-y^2})

This is exactly the crystal field splitting taught in every inorganic chemistry course — derived computationally from one equation.

More broadly, branching rules (how irreps of a group G decompose under restriction to a subgroup H \subset G) are all instances of QS = RQ. This connects to symmetry-breaking distortions in phase transitions: when a crystal's symmetry lowers from G to H, the allowed distortion pathways are determined by which irreps of G become reducible under H.

8.8) Equivariant Linear Maps

Now we turn to the application that motivates much of this machinery: building symmetry-aware neural networks. A standard neural network is built from linear layers (matrix multiplications) composed with nonlinear activation functions. If we want the network to respect a symmetry group G, we need each operation to be equivariant — meaning the operation commutes with the group action:

In words: transforming the input and then applying f gives the same result as applying f and then transforming the output. (When D' = D, the output transforms the same way as the input. When D' is the trivial representation, we call f invariant.)

One of the most fundamental operations in a neural network is a linear map \mathbf{y} = W\mathbf{x}. For this to be equivariant, we need:

This is exactly QS = RQ with S = D_\text{out}, R = D_\text{in}, and Q = W! The allowed weight matrices are the intertwiners — they live in the nullspace of P_\text{all}. (Note that convolution is also fundamentally a linear operation — see the group convolution notes for the connection. The "steerable" formulation used in equivariant neural networks for atomistic systems like NequIP and MACE is a topic for a future set of course notes.)

By Schur's lemma:

• If D_\text{in} and D_\text{out} are inequivalent irreps: W = 0 (no equivariant map exists)
• If D_\text{in} and D_\text{out} are the same irrep: W = c \cdot I (exactly 1 free parameter)
• For reducible representations: the allowed W has block structure dictated by which irreps appear on each side

For example, an equivariant linear layer mapping l = 1 \to l = 1 has exactly 1 learnable parameter (a scalar multiple of the identity). A layer mapping 2 \times (l{=}0) + 2 \times (l{=}1) + 1 \times (l{=}2) \to 2 \times (l{=}0) + 2 \times (l{=}1) + 1 \times (l{=}2) has only 9 free parameters instead of the 13 \times 13 = 169 of an unconstrained matrix — an 18.8\times reduction.

Use the interactive graphic below to explore how Schur's lemma constrains W for different choices of input and output irreps:

9) Act 4: Equivariant Machine Learning

9.1) Equivariant Neural Networks

A key insight for applying symmetry to machine learning: we only need to build in the symmetry of empty space — e.g. for 3D atomic systems, the full rotation group O(3) and translations (the Euclidean group E(n)). We do not need a different model for molecules with C_{2v} symmetry versus T_d versus O_h. Why? Because the data itself lowers the symmetry. An equivariant model starts with the full symmetry of the ambient space, and the atomic positions in the input break that symmetry down to whatever the actual point group is. This is exactly the branching/subduction we saw in crystal field theory — but happening automatically through the data rather than being hard-coded.

This means a single equivariant architecture can handle any molecule, any crystal, any symmetry — the model learns to respect the symmetries that are present and break the ones that the data breaks.

Modern equivariant graph neural networks for atomistic simulation — including MACE, NequIP, Allegro, and BOTNet — are built from two types of layers:

1. Tensor product layers: Combine features using CG coefficients (solutions to QS = RQ)
2. Equivariant linear layers: Weight matrices constrained by QS = RQ

Every learnable parameter in these architectures lives in a solution space of QS = RQ. The dramatic parameter reduction — often 10-20\times fewer weights than unconstrained networks — explains why equivariant models achieve state-of-the-art accuracy with far less training data.

This data efficiency is crucial for materials science, where generating training data (DFT calculations) is expensive: hours per data point versus milliseconds for a forward pass.

9.2) Generative AI for Materials

The same symmetry constraints apply to generative models for crystal structures and molecular conformations:

• Equivariant diffusion models (DiffCSP, CDVAE, FlowMM) use equivariant score networks whose architecture is constrained by QS = RQ
• Equivariant normalizing flows require equivariant coupling layers — again constrained by QS = RQ
• Invariant energy models used as priors must satisfy E(g \cdot x) = E(x), which is the l = 0 case of equivariance

The physics guarantee is the same: if the model's symmetry constraints are built in via QS = RQ, the generated structures automatically respect the relevant symmetry group — no data augmentation needed.

10) Act 5: The Unifying Picture

One equation, many applications:

The power of this framing is that you never need to memorize special-case formulas. Whether you are computing CG coefficients, decomposing vibrational modes, constraining a neural network, or deriving crystal field splittings, you are always doing the same thing: setting up S and R, building P_\text{all}, and finding its nullspace.

11) Resources

• Tutorial Notebook — the live-code Colab notebook for this tutorial
• symm4ml — the Python package built by students in 6.7970/8.750, used throughout this tutorial. The version installed in the Colab notebook is an obfuscated build — students implement the functions themselves for homework, and the obfuscated library lets them check their answers against the course implementation.
• e3nn — equivariant neural network library for PyTorch
• 6.7970/8.750 — full MIT course: Symmetry and its Application to Machine Learning

11.1) Course Notes

For deeper treatment of the topics covered in this tutorial, see the full course notes.