Integrating adaptive tensor product computation from BranchIP into physics-driven specialized machine learning force fields limits the computational overhead of equivariant GNNs during long-term materials dynamics simulations without degrading energy conservation.

Replacing the standard O(n·L³) or worse full tensor product contraction in equivariant message-passing force fields (e.g., NequIP/MACE-style architectures using e3nn Clebsch-Gordan tensor products) with an adaptive, sparsity-aware tensor product computation scheme ("BranchIP") will (a) reduce wall-clock time per MD integration step by ≥30% and peak memory by ≥20% at fixed model accuracy (energy MAE within 1 meV/atom, force MAE within 20 meV/Å of baseline on a held-out test set), and (b) preserve long-timescale energy conservation, defined as drift in total energy ≤0.1 meV/atom/ns averaged over a 1-ns NVE trajectory at 300K, statistically indistinguishable (p>0.05, paired t-test) from the non-adaptive baseline architecture, across at least 3 chemically distinct systems (a molecular liquid, a crystalline solid, an amorphous/interfacial system).

Minimum viable test: single-system, single-architecture ablation.

1. Train baseline MACE (l_max=2, 2 layers, 128 channels) on a public dataset (e.g., 3BPA or revised MD17 subset) to convergence.
2. Implement adaptive tensor product module as a drop-in replacement for the e3nn tensor product layer, matched parameter count (±5%).
3. Retrain identical architecture with adaptive module, same hyperparameters, same data splits, 3 random seeds each.
4. Benchmark: (a) per-step wall-clock time and peak memory on fixed hardware, (b) test-set energy/force MAE, (c) 1-ns NVE MD energy conservation drift, (d) force-field conservativeness check.
5. Compare against baseline using paired statistical tests across seeds.

# Pseudocode: Adaptive Tensor Product (BranchIP-style) module

class AdaptiveTensorProduct(nn.Module):
    def __init__(self, irreps_in1, irreps_in2, irreps_out, sparsity_init=0.5):
        self.cg_paths = build_cg_paths(irreps_in1, irreps_in2, irreps_out)
        self.path_importance = nn.Parameter(torch.ones(len(self.cg_paths)))
        self.sparsity_schedule = AnnealedSigmoid(init=sparsity_init)

    def forward(self, x1, x2, edge_attr, training_step):
        gate = self.sparsity_schedule(self.path_importance, training_step)
        # soft differentiable gating preserves gradient flow -> conservativeness
        outputs = []
        for path, g in zip(self.cg_paths, gate):
            if g > PRUNE_THRESHOLD or training_mode:
                contribution = cg_contract(x1, x2, path) * g
                outputs.append(contribution)
        return sum_irreps(outputs)

# Integration into MACE/NequIP message passing layer
class EquivariantConvLayer(nn.Module):
    def forward(self, node_feats, edge_index, edge_sh, edge_scalars):
        messages = AdaptiveTensorProduct(node_feats[src], edge_sh, out_irreps)
        aggregated = scatter_sum(messages, edge_index[dst])
        return self.update_mlp(aggregated)

# Force computation (must remain autograd-exact for conservation)
energy = model(positions, species)
forces = -torch.autograd.grad(energy.sum(), positions, create_graph=True)[0]

# Validation hook: finite-difference check
assert torch.allclose(forces, numerical_grad(model, positions), atol=1e-4)