Use when you have validated symmetry groups and need to design neural network architecture that respects those symmetries. Invoke when user mentions equivariant layers, G-CNN, e3nn, steerable networks, building symmetry into model, or needs architecture recommendations for specific symmetry groups. Provides architecture patterns and implementation guidance.
Recommends equivariant neural network architectures for specific symmetry groups. Triggers when users mention G-CNNs, e3nn, steerable networks, or building symmetry into models. Provides layer selection, topology design, and library recommendations.
/plugin marketplace add lyndonkl/claude/plugin install lyndonkl-thinking-frameworks-skills@lyndonkl/claudeThis skill inherits all available tools. When active, it can use any tool Claude has access to.
resources/evaluators/rubric_architecture.jsonresources/methodology.mdresources/templates.mdThis skill helps you design neural network architectures that respect identified symmetry groups. Given a validated group specification, it recommends architecture patterns, specific libraries, and implementation strategies.
The payoff: Equivariant architectures have fewer parameters, train faster, generalize better, and are more robust to distribution shift.
Copy this checklist and track your progress:
Architecture Design Progress:
- [ ] Step 1: Review group specification and requirements
- [ ] Step 2: Select architecture family
- [ ] Step 3: Choose specific layers and components
- [ ] Step 4: Design network topology
- [ ] Step 5: Select implementation library
- [ ] Step 6: Create architecture specification
Step 1: Review group specification and requirements
Gather the validated group specification. Confirm: which group(s) are involved, whether invariance or equivariance is needed, the data domain (images, point clouds, graphs, etc.), task type (classification, regression, generation), and any computational constraints. If group isn't specified, work with user to identify it first.
Step 2: Select architecture family
Match the symmetry group to an architecture family using Architecture Selection Guide. Key families: G-CNNs for discrete groups on grids, Steerable CNNs for continuous 2D groups, e3nn/NequIP for E(3) on point data, GNNs for permutation on graphs, DeepSets for permutation on sets. Consider trade-offs between expressiveness and efficiency.
Step 3: Choose specific layers and components
Select layer types based on Layer Patterns. For each layer decide: convolution type (regular, group, steerable), nonlinearity (must preserve equivariance - use gated, norm-based, or tensor product), normalization (batch norm breaks equivariance - use layer norm or equivariant batch norm), pooling (for invariant outputs: use invariant pooling; for equivariant: preserve structure). For detailed design methodology, see Methodology Details.
Step 4: Design network topology
Design the overall network structure: encoder architecture (how features are extracted), feature representations at each stage (irreps for Lie groups), pooling/aggregation strategy, output head matching task requirements. Use Topology Patterns for common designs. Balance depth vs. width for your group size.
Step 5: Select implementation library
Choose library based on Library Reference. Match to your group, framework preference (PyTorch/JAX), and performance needs. Popular choices: e3nn (E(3)/O(3), PyTorch), escnn (discrete groups, PyTorch), pytorch_geometric (permutation, PyTorch). Ensure library supports your specific group.
Step 6: Create architecture specification
Document the design using Output Template. Include: layer-by-layer specification, representation types, library dependencies, expected parameter count, and pseudo-code or actual code skeleton. This specification guides implementation and subsequent equivariance verification. For ready-to-use implementation templates, see Code Templates. Quality criteria for this output are defined in Quality Rubric.
| Group | Domain | Recommended Architecture | Library |
|---|---|---|---|
| Cₙ, Dₙ | 2D Images | G-CNN, Group Equivariant CNN | escnn, e2cnn |
| SO(2), O(2) | 2D Images | Steerable CNN, Harmonic Networks | escnn |
| SO(3) | Spherical | Spherical CNN | e3nn, s2cnn |
| SE(3), E(3) | Point clouds | Equivariant GNN, Tensor Field Networks | e3nn, NequIP |
| Sₙ | Sets | DeepSets | pytorch, jax |
| Sₙ | Graphs | Message Passing GNN | pytorch_geometric |
| E(3) × Sₙ | Molecules | E(3) Equivariant GNN | e3nn, SchNet |
| Task | Output Type | Key Consideration |
|---|---|---|
| Classification | Invariant scalar | Use invariant pooling |
| Regression (scalar) | Invariant scalar | Same as classification |
| Segmentation | Equivariant per-point | Preserve equivariance to output |
| Force prediction | Equivariant vector | Output as l=1 irrep |
| Pose estimation | Equivariant transform | Output rotation + translation |
| Generation | Equivariant structure | Equivariant decoder |
Standard G-Convolution:
(f ⋆ ψ)(g) = ∫_G f(h) ψ(g⁻¹h) dh
Steerable Convolution:
e3nn Tensor Product Layer:
# Combine features with different angular momenta
tp = o3.FullyConnectedTensorProduct(
irreps_in1, irreps_in2, irreps_out
)
output = tp(input1, input2)
Problem: Standard nonlinearities (ReLU, etc.) break equivariance.
Solutions:
| Type | How It Works | When to Use |
|---|---|---|
| Norm-based | Apply nonlinearity to | |
| Gated | Use invariant to gate equivariant | General purpose |
| Tensor product | Nonlinearity via Clebsch-Gordan | e3nn, high-quality |
| Invariant features | Only apply to l=0 components | Simple, fast |
Batch Norm: Breaks equivariance (different stats per orientation) Solutions:
To get invariant output from equivariant features:
| Method | Formula | When to Use |
|---|---|---|
| Mean pooling | mean over group | Continuous groups |
| Sum pooling | sum over elements | Sets, graphs |
| Max pooling | max | |
| Attention pooling | weighted sum | When importance varies |
Input → [Equiv. Encoder] → Latent (equiv.) → [Equiv. Decoder] → Output
Input → [Equiv. Encoder] → Features (equiv.) → [Invariant Pool] → [MLP] → Class
Nodes → [MP Layer 1] → [MP Layer 2] → ... → [Aggregation] → Output
Groups: E(3), O(3), SO(3) Strengths: Full irrep support, tensor products, spherical harmonics Use for: Molecular modeling, 3D point clouds, physics
from e3nn import o3
irreps = o3.Irreps("2x0e + 2x1o + 1x2e") # 2 scalars, 2 vectors, 1 tensor
Groups: Discrete groups (Cₙ, Dₙ), continuous 2D (SO(2), O(2)) Strengths: Image processing, well-documented Use for: 2D images with rotation/reflection symmetry
from escnn import gspaces, nn
gspace = gspaces.rot2dOnR2(N=4) # C4 rotation group
Groups: Permutation (Sₙ) Strengths: Graphs, batching, many GNN layers Use for: Graph classification/regression, node prediction
from torch_geometric.nn import GCNConv, global_mean_pool
| Library | Groups | Framework | Notes |
|---|---|---|---|
| NequIP | E(3) | PyTorch | Molecular dynamics |
| MACE | E(3) | PyTorch | Molecular potentials |
| jraph | Sₙ | JAX | Graph networks |
| geomstats | Lie groups | NumPy/PyTorch | Manifold learning |
ARCHITECTURE SPECIFICATION
==========================
Target Symmetry: [Group name and notation]
Symmetry Type: [Invariant/Equivariant]
Task: [Classification/Regression/etc.]
Domain: [Images/Point clouds/Graphs/etc.]
Architecture Family: [e.g., E(3) Equivariant GNN]
Library: [e.g., e3nn]
Layer Specification:
1. Input Layer
- Input type: [e.g., 3D coordinates + features]
- Representation: [e.g., positions (l=1) + scalars (l=0)]
2. [Layer Name]
- Type: [Convolution/Tensor Product/Message Passing]
- Input irreps: [specification]
- Output irreps: [specification]
- Nonlinearity: [Gated/Norm/None]
3. [Continue for each layer...]
N. Output Layer
- Aggregation: [Mean/Sum/Attention]
- Output: [Invariant scalar / Equivariant vector / etc.]
Estimated Parameters: [count]
Key Dependencies: [library versions]
Code Skeleton:
[Provide implementation outline or pseudo-code]
NEXT STEPS:
- Implement the architecture using the specified library
- Verify equivariance through numerical testing after implementation
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.