# Euclidean neural networks

## What is `e3nn`

?

`e3nn`

is a python library based on pytorch to create equivariant neural networks for the group \(O(3)\).

## Where to start?

Guide to the

`e3nn.o3.Irreps`

: Irreducible representationsGuide to implement a Convolution

The simplest example to start with is Tetris Polynomial Example.

Guide to implement a Transformer

## Demonstration

All the functions to manipulate rotations (rotation matrices, Euler angles, quaternions, convertions, …) can be found here Parametrization of Rotations.
The irreducible representations of \(O(3)\) (more info at Irreps) are represented by the class `e3nn.o3.Irrep`

.
The direct sum of multiple irrep is described by an object `e3nn.o3.Irreps`

.

If two tensors \(x\) and \(y\) transforms as \(D_x = 2 \times 1_o\) (two vectors) and \(D_y = 0_e + 1_e\) (a scalar and a pseudovector) respectively, where the indices \(e\) and \(o\) stand for even and odd – the representation of parity,

```
import torch
from e3nn import o3
irreps_x = o3.Irreps('2x1o')
irreps_y = o3.Irreps('0e + 1e')
x = irreps_x.randn(-1)
y = irreps_y.randn(-1)
irreps_x.dim, irreps_y.dim
```

```
(6, 4)
```

their outer product is a \(6 \times 4\) matrix of two indices \(A_{ij} = x_i y_j\).

```
A = torch.einsum('i,j', x, y)
A
```

```
tensor([[-1.6085e-03, -6.1707e-03, 4.3348e-04, -1.7051e-02],
[ 4.5079e-02, 1.7294e-01, -1.2149e-02, 4.7786e-01],
[-1.3860e-01, -5.3171e-01, 3.7352e-02, -1.4692e+00],
[ 3.5680e-03, 1.3688e-02, -9.6156e-04, 3.7822e-02],
[ 9.4638e-02, 3.6306e-01, -2.5505e-02, 1.0032e+00],
[ 1.7074e-01, 6.5501e-01, -4.6014e-02, 1.8099e+00]])
```

If a rotation is applied to the system, this matrix will transform with the representation \(D_x \otimes D_y\) (the tensor product representation).

Which can be represented by

```
R = o3.rand_matrix()
D_x = irreps_x.D_from_matrix(R)
D_y = irreps_y.D_from_matrix(R)
plt.imshow(torch.kron(D_x, D_y), cmap='bwr', vmin=-1, vmax=1);
```

This representation is not irreducible (is reducible). It can be decomposed into irreps by a change of basis. The outerproduct followed by the change of basis is done by the class `e3nn.o3.FullTensorProduct`

.

```
tp = o3.FullTensorProduct(irreps_x, irreps_y)
print(tp)
tp(x, y)
```

```
FullTensorProduct(2x1o x 1x0e+1x1e -> 2x0o+4x1o+2x2o | 8 paths | 0 weights)
```

```
tensor([-0.8588, 1.0381, -0.0016, 0.0451, -0.1386, 0.0036, 0.0946, 0.1707,
0.3115, -0.3639, -0.1220, 0.7419, 0.4364, -0.2574, -0.3880, 0.1226,
0.5924, 0.3643, -1.0345, 0.4899, 0.2560, -0.7653, 0.6768, 1.2701])
```

As a sanity check, we can verify that the representation of the tensor prodcut is block diagonal and of the same dimension.

```
D = tp.irreps_out.D_from_matrix(R)
plt.imshow(D, cmap='bwr', vmin=-1, vmax=1);
```

`e3nn.o3.FullTensorProduct`

is a special case of `e3nn.o3.TensorProduct`

, other ones like `e3nn.o3.FullyConnectedTensorProduct`

can contained weights what can be learned, very useful to create neural networks.