Cuequivariance

NVIDIAOfficialCreated by Mario GeigerDistributed by NVIDIA

Skill
Tool integration
Data and AI
Apache-2.0
Medium risk

From the author

Use when defining cuEquivariance groups and irreps, building equivariant tensor products, or validating segmented polynomials with NumPy.

— the description by Mario Geiger

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

cuequivariance provides a framework for handling group theory and equivariant tensor products in Python. It enables the definition of irreducible representations (irreps) for Lie groups like SO3, O3, and SU2, or custom groups, and facilitates the construction of equivariant polynomials. The library uses segmented tensor products to manage contractions across varying shapes, supporting both dense EquivariantPolynomials and dictionary-based IrDictPolynomials for structured data.

What it does

Defines irreducible representations (irreps) for standard and custom Lie groups.
Builds equivariant tensor products using segmented tensor product abstractions.
Supports custom group definitions including selection rules and Clebsch-Gordan coefficients.
Provides high-level descriptors for common operations like spherical harmonics and symmetric contractions.
Manages memory layout and irrep metadata for efficient NumPy-based evaluation.
Normalizes path coefficients to ensure numerical stability in tensor contractions.

When to use it

When building equivariant neural network layers or mathematical models requiring group symmetry.
When you need to define custom symmetry groups and their associated representation algebra.
When performing tensor contractions that must respect specific group-theoretic selection rules.
When prototyping equivariant operations on CPU using NumPy before moving to framework-specific backends.

Advantages

Strict adherence to group-theoretic principles for robust equivariant modeling.
Flexible support for both standard (SO3, O3, SU2) and user-defined symmetry groups.
Efficient handling of segmented data structures and irrep-based layouts.
Provides clear abstractions for complex tensor contractions via Einstein notation.

Usage examples

“How do I define a custom Z2 group with parity-based selection rules?”: Subclass cue.Irrep, implement the required methods including __mul__ for selection rules, clebsch_gordan for coefficients, and discrete_generators for symmetry.
“How can I create a linear equivariant map between two sets of irreps?”: Use cue.descriptors.linear(irreps_in, irreps_out) to generate an EquivariantPolynomial that handles the weight-input contraction automatically.
“How do I evaluate a tensor product using dictionary-based irrep inputs?”: Use the _ir_dict variants of descriptors, such as channelwise_tensor_product_ir_dict, and pass operands as dictionaries split by irrep.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/cuequivariance/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip cuequivariance.zip -d .agents/skills

Documentation by Mario Geiger

cuequivariance: Groups, Irreps, and Segmented Polynomials

Purpose

cuequivariance (imported as cue) provides two core abstractions:

Group theory: Irrep subclasses define irreducible representations of Lie groups (SO3, O3, SU2, or custom). Irreps manages collections with multiplicities.
Segmented polynomials: SegmentedTensorProduct describes tensor contractions over segments of varying shape, linked by Path objects carrying Clebsch-Gordan coefficients. SegmentedPolynomial wraps multiple STPs into a polynomial with named inputs/outputs. Two higher-level wrappers attach group representations:
- EquivariantPolynomial — dense operands with IrrepsAndLayout metadata
- IrDictPolynomial — operands already split by irrep, with per-group Irreps metadata for the dict[Irrep, Array] workflow

Inputs

Required inputs: requested operation, group, input irreps and multiplicities, output irrep types, layout, batch shapes, dtype, and weight ownership. Take explicit user requirements first, then existing project definitions; state defaults for unspecified values. Derive operand sizes and output block order from the descriptor. For custom groups, also establish the selection rules, generators, and Clebsch-Gordan coefficients. Optional inputs include test rotations and a framework backend.

Prerequisites

Use Python 3.10+ with cuequivariance and its NumPy, SciPy, opt_einsum, SymPy, and NetworkX dependencies. Reuse the project's interpreter and lockfile. If setup is needed outside an existing project, the bundled CPU requirements pin the source revision used by these examples; install them with that interpreter's pip. Core NumPy execution requires no GPU stack or API credentials. Check the installed version and API availability before using IrDictPolynomial with an older package.

Instructions

Check the installed version and requested backend. Install cuequivariance for CPU NumPy work; JAX and PyTorch execution use the separate cuequivariance-jax and cuequivariance-torch skills. Inspect available APIs before using newer features such as IrDictPolynomial in an older environment.
Establish the group, input irreps, multiplicities, layout, and batch shapes before building a descriptor. Preserve the descriptor's actual output block order; a regrouped irrep summary does not reorder its output array.
Prefer a built-in descriptor. For a custom group, validate parsing, group relations, selection rules, and Clebsch-Gordan covariance on CPU first. Complex mathematical representations do not imply complex CUDA support.
Execute a small deterministic NumPy example and check shapes and equivariance. IrDictPolynomial carries metadata; execute its .polynomial with operands split according to .input_irreps and .output_irreps, including weights first when present.
Convert mul_ir and ir_mul by transposing the multiplicity and representation axes within each irrep block. A flat reshape alone changes the represented features.

Source paths below are relative to the cuequivariance/ project inside a source checkout. When using this skill separately, inspect the installed package with cue.__file__ or consult https://github.com/NVIDIA/cuEquivariance. The repository is not required for the examples.

Limitations

Core descriptors and NumPy evaluation do not provide JAX or PyTorch execution kernels; use the corresponding frontend for framework execution and gradients.
Custom-group mathematics must be checked independently. A valid complex representation does not establish support in a particular CUDA kernel.
IrDictPolynomial describes split operands; it does not convert high-level dictionaries into the ordered arrays accepted by its underlying polynomial. Preserve the descriptor's metadata and layout when assembling those arrays.

Troubleshooting

Symptom	Check and correction
Import fails or an API is absent	Check the interpreter, installed version, and module location. Use the project's compatible dependencies or the bundled requirements when setting up a standalone environment.
Operand size or output shape is wrong	Compare each array with the descriptor's input/output dimensions; include the weights operand first when present.
Values disagree after a layout conversion	Transpose multiplicity and representation axes within each irrep block before flattening; keep output data in the descriptor's block order.
Custom-group equivariance fails	Check selection rules, generator relations, and CG covariance on a small NumPy example before changing execution backends.

Examples

The examples below cover custom groups, descriptors, layouts, and NumPy execution. Some snippets extend variables from the preceding snippet; the final complete example can be run independently.

Defining a custom group

Subclass cue.Irrep (a frozen dataclass) and implement:

from __future__ import annotations
import dataclasses
import re
from typing import Iterator
import numpy as np
import cuequivariance as cue

@dataclasses.dataclass(frozen=True)
class Z2(cue.Irrep):
    odd: bool  # dataclass field -- required for correct __eq__ and __hash__

    # No __init__ needed -- @dataclass(frozen=True) generates it: Z2(odd=True)

    @classmethod
    def regexp_pattern(cls) -> re.Pattern:
        # Pattern whose first group is passed to from_string
        return re.compile(r"(odd|even)")

    @classmethod
    def from_string(cls, string: str) -> Z2:
        if string not in ("odd", "even"):
            raise ValueError(f"Invalid Z2 irrep: {string!r}")
        return cls(odd=string == "odd")

    def __repr__(rep: Z2) -> str:
        return "odd" if rep.odd else "even"

    def __mul__(rep1: Z2, rep2: Z2) -> Iterator[Z2]:
        # Selection rule: which irreps appear in the tensor product rep1 x rep2
        return [Z2(odd=rep1.odd ^ rep2.odd)]

    @classmethod
    def clebsch_gordan(cls, rep1: Z2, rep2: Z2, rep3: Z2) -> np.ndarray:
        # Shape: (num_paths, rep1.dim, rep2.dim, rep3.dim)
        if rep3 in rep1 * rep2:
            return np.array([[[[1]]]])
        else:
            return np.zeros((0, 1, 1, 1))

    @property
    def dim(rep: Z2) -> int:
        return 1

    def __lt__(rep1: Z2, rep2: Z2) -> bool:
        # Ordering for sorting; dimension is compared first by the base class
        return rep1.odd < rep2.odd

    @classmethod
    def iterator(cls) -> Iterator[Z2]:
        # Must yield trivial irrep first
        for odd in [False, True]:
            yield Z2(odd=odd)

    def discrete_generators(rep: Z2) -> np.ndarray:
        # Shape: (num_generators, dim, dim)
        if rep.odd:
            return -np.ones((1, 1, 1))
        else:
            return np.ones((1, 1, 1))

    def continuous_generators(rep: Z2) -> np.ndarray:
        # Shape: (lie_dim, dim, dim) -- Z2 is discrete, so lie_dim=0
        return np.zeros((0, rep.dim, rep.dim))

    def algebra(self) -> np.ndarray:
        # Shape: (lie_dim, lie_dim, lie_dim) -- structure constants [X_i, X_j] = A_ijk X_k
        return np.zeros((0, 0, 0))


# Usage:
irreps = cue.Irreps(Z2, "3x odd + 2x even")  # dim=5

Required methods summary

Method	Returns	Purpose
`regexp_pattern()`	`re.Pattern`	Parse string like `"1"`, `"0e"`, `"odd"`
`from_string(s)`	`Irrep`	Construct from matched string
`__repr__`	`str`	Canonical string form
`__mul__(a, b)`	`Iterator[Irrep]`	Selection rule for tensor product
`clebsch_gordan(a, b, c)`	`ndarray (n, d1, d2, d3)`	CG coefficients
`dim` (property)	`int`	Dimension of representation
`__lt__(a, b)`	`bool`	Ordering (dimension first, then custom)
`iterator()`	`Iterator[Irrep]`	All irreps, trivial first
`continuous_generators()`	`ndarray (lie_dim, dim, dim)`	Lie algebra generators
`discrete_generators()`	`ndarray (n, dim, dim)`	Finite symmetry generators
`algebra()`	`ndarray (lie_dim, lie_dim, lie_dim)`	Structure constants

Built-in groups

cue.SO3(l): 3D rotations. l is a non-negative integer. dim = 2l+1. String: "0", "1", "2".
cue.O3(l, p): 3D rotations + parity. p=+1 (even) or p=-1 (odd). String: "0e", "1o", "2e".
cue.SU2(j): Spin group. j is a non-negative half-integer. String: "0", "1/2", "1".

Irreps and layout

irreps = cue.Irreps("SO3", "16x0 + 4x1 + 2x2")  # 16 scalars, 4 vectors, 2 rank-2
irreps.dim   # 16*1 + 4*3 + 2*5 = 38

for mul, ir in irreps:
    print(mul, ir, ir.dim)  # 16 0 1, then 4 1 3, then 2 2 5

IrrepsLayout controls memory order within each (mul, ir) block:

cue.ir_mul: data ordered as (ir.dim, mul) — used by all descriptors and ir_dict internally
cue.mul_ir: data ordered as (mul, ir.dim) — used by nnx dict[Irrep, Array] and PyTorch

IrrepsAndLayout combines irreps with a layout into a Rep:

rep = cue.IrrepsAndLayout(cue.Irreps("SO3", "4x0 + 2x1"), cue.ir_mul)
rep.dim  # 10

Building a SegmentedTensorProduct from scratch

The subscripts string uses Einstein notation. Operands are comma-separated, coefficient modes follow +.

# Matrix-vector multiply: y_i = sum_j M_ij * x_j
d = cue.SegmentedTensorProduct.from_subscripts("ij,j,i")
d.add_segment(0, (3, 4))  # operand 0: matrix segment of shape (3, 4)
d.add_segment(1, (4,))     # operand 1: vector of size 4
d.add_segment(2, (3,))     # operand 2: output vector of size 3
d.add_path(0, 0, 0, c=1.0) # link segments 0,0,0 with coefficient=1.0

poly = cue.SegmentedPolynomial.eval_last_operand(d)  # last operand becomes output
[y] = poly(M_flat, x)  # numpy evaluation

Multi-segment STP (how descriptors work internally)

Descriptors build STPs with multiple segments per operand. Each segment corresponds to an irrep block:

# Linear equivariant map: output[iv] = sum_u weight[uv] * input[iu]
d = cue.SegmentedTensorProduct.from_subscripts("uv,iu,iv")

# Segment for l=1: ir_dim=3, mul_in=2, mul_out=5
s_in_0 = d.add_segment(1, (3, 2))    # input block
s_out_0 = d.add_segment(2, (3, 5))   # output block
d.add_path((2, 5), s_in_0, s_out_0, c=1.0)

# Segment for l=0: ir_dim=1, mul_in=4, mul_out=3
s_in_1 = d.add_segment(1, (1, 4))
s_out_1 = d.add_segment(2, (1, 3))
d.add_path((4, 3), s_in_1, s_out_1, c=1.0)

Weights operand

For weighted tensor products (subscript starting with uvw or uv), the first operand is always weights. The weight segment shape is (mul_1, mul_2, ...) matching the multiplicity modes. The weights operand gets new_scalars() irreps since weights are invariant.

CG coefficients as path coefficients

d = cue.SegmentedTensorProduct.from_subscripts("uvw,iu,jv,kw+ijk")
# For each pair of input irreps and each output irrep in the selection rule:
for cg in cue.clebsch_gordan(ir1, ir2, ir3):
    # cg has shape (ir1.dim, ir2.dim, ir3.dim)
    d.add_path((mul1, mul2, mul3), seg_in1, seg_in2, seg_out, c=cg)

Descriptors

All descriptors come in two variants:

Original — returns EquivariantPolynomial with dense operands
_ir_dict — returns IrDictPolynomial with operands already split by irrep

EquivariantPolynomial descriptors

# Fully connected tensor product (all input-output irrep combinations)
e = cue.descriptors.fully_connected_tensor_product(
    16 * cue.Irreps("SO3", "0 + 1 + 2"),
    16 * cue.Irreps("SO3", "0 + 1 + 2"),
    16 * cue.Irreps("SO3", "0 + 1 + 2"),
)

# Channelwise tensor product (same-channel only, sparse)
e = cue.descriptors.channelwise_tensor_product(
    64 * cue.Irreps("SO3", "0 + 1"), cue.Irreps("SO3", "0 + 1"),
    cue.Irreps("SO3", "0 + 1"), simplify_irreps3=True,
)

# Full (weightless) tensor product
e = cue.descriptors.full_tensor_product(
    cue.Irreps("SO3", "2x0 + 1x1"), cue.Irreps("SO3", "0 + 1"),
)

# Elementwise tensor product (paired channels)
e = cue.descriptors.elementwise_tensor_product(
    cue.Irreps("SO3", "4x0 + 4x1"), cue.Irreps("SO3", "4x0 + 4x1"),
)

# Linear equivariant map (weight x input)
e = cue.descriptors.linear(
    cue.Irreps("SO3", "4x0 + 2x1"),
    cue.Irreps("SO3", "3x0 + 5x1"),
)

# Spherical harmonics
e = cue.descriptors.spherical_harmonics(cue.SO3(1), [0, 1, 2, 3])

# Symmetric contraction (MACE-style)
e = cue.descriptors.symmetric_contraction(
    64 * cue.Irreps("SO3", "0 + 1 + 2"),
    64 * cue.Irreps("SO3", "0 + 1"),
    (1, 2, 3),
)

IrDictPolynomial descriptors

Each _ir_dict constructor returns an IrDictPolynomial: .polynomial is a SegmentedPolynomial already split by irrep, and .input_irreps / .output_irreps describe the operand groups. Each (mul, ir) block in those groups corresponds to one polynomial operand of size mul * ir.dim.

channelwise_tensor_product_ir_dict always simplifies output irreps. To compare with its dense counterpart, pass simplify_irreps3=True to channelwise_tensor_product, or explicitly regroup the output data as well as its irrep metadata. The third argument filters irrep types; it does not set output multiplicities.

# Channelwise tensor product
desc = cue.descriptors.channelwise_tensor_product_ir_dict(
    64 * cue.Irreps("SO3", "0 + 1"),
    cue.Irreps("SO3", "0 + 1"),
    cue.Irreps("SO3", "0 + 1"),
)
desc.polynomial       # SegmentedPolynomial
desc.input_irreps     # (weight_irreps, irreps1, irreps2)
desc.output_irreps    # (irreps_out,)

# Scale coefficients and inspect individual input operands
scaled_poly = desc.polynomial * 0.5
for i, op in enumerate(desc.polynomial.inputs):
    print(f"Input {i}: size={op.size}, num_segments={op.num_segments}")

Other constructors use the same operand metadata contract:

# Fully connected tensor product
desc = cue.descriptors.fully_connected_tensor_product_ir_dict(irreps1, irreps2, irreps3)

# Full (weightless) tensor product
desc = cue.descriptors.full_tensor_product_ir_dict(irreps1, irreps2)

# Elementwise tensor product
desc = cue.descriptors.elementwise_tensor_product_ir_dict(irreps1, irreps2)

# Linear
desc = cue.descriptors.linear_ir_dict(irreps_in, irreps_out)

# Spherical harmonics
desc = cue.descriptors.spherical_harmonics_ir_dict(cue.O3(1, -1), [0, 1, 2, 3])

# Symmetric contraction
desc = cue.descriptors.symmetric_contraction_ir_dict(irreps_in, irreps_out, (1, 2, 3))

split_polynomial_by_irreps

Use this helper to split an existing SegmentedPolynomial operand at irrep boundaries. Supply the operand's irreps explicitly because the bare polynomial has no representation metadata:

poly = e.polynomial  # from an EquivariantPolynomial
poly = cue.split_polynomial_by_irreps(poly, 2, irreps_sh)   # split input 2
poly = cue.split_polynomial_by_irreps(poly, 1, irreps_in)   # split input 1
poly = cue.split_polynomial_by_irreps(poly, -1, irreps_out) # split output

EquivariantPolynomial key methods

e.inputs     # tuple of Rep (group representations for each input)
e.outputs    # tuple of Rep
e.polynomial # the underlying SegmentedPolynomial

# Numpy evaluation
[out] = e(weights, input1, input2)

# Preparing for uniform_1d execution (see cuequivariance_jax SKILL.md)
e_ready = e.squeeze_modes().flatten_coefficient_modes()

# Split dense operands using the representation metadata already attached to e
e_split = e.split_operand_by_irrep(1).split_operand_by_irrep(-1)

# Scale all coefficients
e_scaled = e * 0.5

# Fuse compatible STPs
e_fused = e.fuse_stps()

normalize_paths_for_operand

Called internally by descriptors. Normalizes path coefficients so that a random input produces unit-variance output for the specified operand. Critical for numerical stability.

SegmentedPolynomial structure

poly = e.polynomial
poly.num_inputs    # number of input operands
poly.num_outputs   # number of output operands
poly.inputs        # tuple of SegmentedOperand
poly.outputs       # tuple of SegmentedOperand
poly.operations    # tuple of (Operation, SegmentedTensorProduct)

# Each operation maps buffers to STP operands
for op, stp in poly.operations:
    print(op.buffers)  # e.g., (0, 1, 2) means inputs[0], inputs[1] -> outputs[0]
    print(stp.subscripts)

SegmentedOperand

operand = poly.inputs[0]
operand.num_segments     # how many segments
operand.segments         # tuple of shape tuples, e.g., ((3, 4), (1, 2))
operand.size             # total flattened size (sum of products of segment shapes)
operand.ndim             # number of dimensions per segment
operand.all_same_segment_shape()  # True if all segments have identical shape
operand.segment_shape    # the common shape (only if all_same_segment_shape)

Custom equivariant polynomial from scratch

import numpy as np
import cuequivariance as cue

# Build a fully-connected SO3(1)xSO3(1)->SO3(0) tensor product manually
cg = cue.clebsch_gordan(cue.SO3(1), cue.SO3(1), cue.SO3(0))  # shape (1, 3, 3, 1)

d = cue.SegmentedTensorProduct.from_subscripts("uvw,iu,jv,kw+ijk")
d.add_segment(1, (3, 4))   # input1: 4x SO3(1), shape=(ir_dim, mul)
d.add_segment(2, (3, 4))   # input2: 4x SO3(1)
d.add_segment(3, (1, 16))  # output: 16x SO3(0) (4*4 fully connected)

for c in cg:
    d.add_path((4, 4, 16), 0, 0, 0, c=c)

d = d.normalize_paths_for_operand(-1)

poly = cue.SegmentedPolynomial.eval_last_operand(d)
ep = cue.EquivariantPolynomial(
    [
        cue.IrrepsAndLayout(cue.Irreps("SO3", "4x1").new_scalars(d.operands[0].size), cue.ir_mul),
        cue.IrrepsAndLayout(cue.Irreps("SO3", "4x1"), cue.ir_mul),
        cue.IrrepsAndLayout(cue.Irreps("SO3", "4x1"), cue.ir_mul),
    ],
    [cue.IrrepsAndLayout(cue.Irreps("SO3", "16x0"), cue.ir_mul)],
    poly,
)

# Numpy evaluation
w = np.random.randn(ep.inputs[0].dim)
x = np.random.randn(ep.inputs[1].dim)
y = np.random.randn(ep.inputs[2].dim)
[out] = ep(w, x, y)

Key file locations

Component	Path
`Irrep` base class	`cuequivariance/group_theory/representations/irrep.py`
`Rep` base class	`cuequivariance/group_theory/representations/rep.py`
`SO3`	`cuequivariance/group_theory/representations/irrep_so3.py`
`O3`	`cuequivariance/group_theory/representations/irrep_o3.py`
`SU2`	`cuequivariance/group_theory/representations/irrep_su2.py`
`Irreps`	`cuequivariance/group_theory/irreps_array/irreps.py`
`IrrepsLayout`	`cuequivariance/group_theory/irreps_array/irreps_layout.py`
`IrrepsAndLayout`	`cuequivariance/group_theory/irreps_array/irreps_and_layout.py`
`SegmentedTensorProduct`	`cuequivariance/segmented_polynomials/segmented_tensor_product.py`
`SegmentedPolynomial`	`cuequivariance/segmented_polynomials/segmented_polynomial.py`
`EquivariantPolynomial`	`cuequivariance/group_theory/equivariant_polynomial.py`
`IrDictPolynomial`	`cuequivariance/group_theory/ir_dict_polynomial.py`
Descriptors	`cuequivariance/group_theory/descriptors/`
Tensor product descriptors	`cuequivariance/group_theory/descriptors/irreps_tp.py`
`spherical_harmonics`	`cuequivariance/group_theory/descriptors/spherical_harmonics_.py`
`symmetric_contraction`	`cuequivariance/group_theory/descriptors/symmetric_contractions.py`

Files

ATTRIBUTION.mdAdded by AutoGineer922 B
BENCHMARK.md10.1 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md19.2 KiB
evals/config.yml328 B
evals/evals.json6.9 KiB
scripts/requirements.txt280 B
skill-card.md6.5 KiB
skill.oms.sig4.9 KiB

skill-card.md

Description:

Use when defining cuEquivariance groups and irreps, building equivariant tensor products, or validating segmented polynomials with NumPy.

This skill is ready for commercial/non-commercial use.

Owner

NVIDIA

License/Terms of Use:

Apache 2.0

Use Case:

Developers and engineers building geometric (equivariant) neural networks use this skill to define custom groups and irreps, build segmented tensor products with Clebsch-Gordan coefficients, use built-in descriptors, and validate equivariant polynomials with NumPy on CPU.

Deployment Geography for Use:

Global

Requirements / Dependencies:

Requires API Key or External Credential: [No] Credential Type(s): [None]

Do not include secrets in prompts/logs/output; use least-privilege credentials; rotate keys as appropriate.

Known Risks and Mitigations:

Risk: Review before execution as proposals could introduce incorrect or misleading guidance into skills. Mitigation: Review and scan skill before deployment.

Reference(s):

Skill Output:

Output Type(s): [Code, Analysis] Output Format: [Markdown with inline Python code blocks] Output Parameters: [1D] Other Properties Related to Output: [None]

Evaluation Agents Used:

Claude Code (aws/anthropic/bedrock-claude-opus-5-5)
Codex (openai/openai/gpt-6.1-sol)

Evaluation Tasks:

6 evaluation tasks (5 positive, 1 negative), 1 attempt per task, each run in its own isolated sandbox pod (k8s-sandbox environment); each task was also attempted without the skill as a baseline.

Evaluation Metrics Used:

Reported benchmark dimensions:

Security: Is it safe to use? Scored from security (100%).
Correctness: Is the answer correct? Scored from accuracy (100%).
Discoverability: Was the right skill loaded when needed? Scored from skill_execution (100%).
Effectiveness: Did the skill help complete the task? Scored from goal_accuracy (50%) + behavior_check (50%).
Efficiency: Did it avoid wasted tool calls and token usage? Scored from skill_efficiency (50%) + token_efficiency (50%).

Underlying evaluation signals used in this run:

security: Unsafe operations, secret leakage, and unauthorized access.
skill_execution: Whether the expected skill was selected, decoys were avoided, and the workflow executed.
skill_efficiency: Tool-call productivity (legacy wire id; routing is scored under Discoverability).
accuracy: Final-answer correctness against the reference answer.
goal_accuracy: Whether the user's goal was achieved.
behavior_check: Whether the expected workflow behavior was followed.
token_efficiency: Actual uncached prompt plus completion usage (50% of Efficiency).

Evaluation Results:

Overall verdict: ✅ PASS — Recommended for publication

Publication Recommendation: Recommended for publication based on the completed evaluation evidence in this report.

Results at a Glance

Measure	Claude Code (Baseline → Skill Uplift)	Codex (Baseline → Skill Uplift)
Overall	75.1% — baseline ran, but no comparable score was available; uplift unavailable	80.5% — baseline ran, but no comparable score was available; uplift unavailable
Security	83.3% → 33.3% (-50.0 points)	100.0% → 75.0% (-25.0 points)
Correctness	100.0% → 100.0% (±0.0 points)	100.0% → 96.7% (-3.3 points)
Discoverability	84.0% — baseline ran, but no comparable score was available; uplift unavailable	83.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness	95.8% → 91.7% (-4.1 points)	74.2% → 79.6% (+5.4 points)
Efficiency	66.3% — baseline ran, but no comparable score was available; uplift unavailable	68.1% — baseline ran, but no comparable score was available; uplift unavailable

Baseline is the same task attempted without the target skill. Scores are rounded to one decimal; threshold-adjacent values use additional precision so their displayed band matches the verdict. Uplift is derived from those displayed scores and shown in percentage points. A partial dimension was calculated from only the available configured signals.

Comparison details

Shared-source comparisons use the same signals and weights on both conditions. They do not replace the full dimension scores above or change the publication verdict.

Agent	Dimension	Basis	Baseline → With skill (uplift)	Explanation
claude-code	Discoverability	Dimension comparison	N/A	Discoverability is not applicable to the no-skill baseline; there is no installed skill to discover.
claude-code	Efficiency	Token-only comparison	87.7% → 86.7% (-1.0 points)	Only Token Efficiency is comparable; the full dimension scores use different evaluator sources.
codex	Discoverability	Dimension comparison	N/A	Discoverability is not applicable to the no-skill baseline; there is no installed skill to discover.
codex	Efficiency	Token-only comparison	78.6% → 82.9% (+4.3 points)	Only Token Efficiency is comparable; the full dimension scores use different evaluator sources.

Tier Status

Tier	Purpose	Status	Evidence
Tier 1	Static validation	PASSED	11 validator(s); 0 finding(s)
Tier 2	Semantic deduplication	PASSED	2 validator(s); 0 finding(s)
Tier 3	Live agent evaluation	PASS	2 agent(s); 6 task(s)

Skill Version(s):

605793b (source: git SHA, committed 2026-11-03)

Ethical Considerations:

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal team to ensure this skill meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

(For Release on NVIDIA Platforms Only) Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns here.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Mario Geiger

Publisher

NVIDIA (Official)

Distributed by

NVIDIA

Source

NVIDIA/skills · skills/bionemo-cuequivariance · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Mario Geiger or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download cuequivariance.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by Mario Geiger

cuequivariance: Groups, Irreps, and Segmented Polynomials

Purpose

Inputs

Prerequisites

Instructions

Limitations

Troubleshooting

Examples

Defining a custom group

Required methods summary

Built-in groups

Irreps and layout

Building a SegmentedTensorProduct from scratch

Multi-segment STP (how descriptors work internally)

Weights operand

CG coefficients as path coefficients

Descriptors

EquivariantPolynomial descriptors

IrDictPolynomial descriptors

split_polynomial_by_irreps

EquivariantPolynomial key methods

normalize_paths_for_operand

SegmentedPolynomial structure

SegmentedOperand

Custom equivariant polynomial from scratch

Key file locations

Files

skill-card.md

Description: <br>

Owner

License/Terms of Use: <br>

Use Case: <br>

Deployment Geography for Use: <br>

Requirements / Dependencies: <br>

Known Risks and Mitigations: <br>

Reference(s): <br>

Skill Output: <br>

Evaluation Agents Used: <br>

Evaluation Tasks: <br>

Evaluation Metrics Used: <br>

Evaluation Results: <br>

Results at a Glance

Comparison details

Tier Status

Skill Version(s): <br>

Ethical Considerations: <br>

Requirements and compatibility

Security

Attribution and licence

Related skills

Pytorch Lightning

Aeon

Umap Learn

Scikit Learn

Shap

Pufferlib

Download ZIP