✗ Failed on benchmark 2026

Cubic-Group Averaged 3D Convolution

Implementation & benchmark of arXiv:2608.08137 — Cubic-Equivariant Neural Density Functional Theory for Three-Dimensional Lattice Fluids

Usefulness8/10
Difficulty4/10
Novelty5/10

Source paper: Cubic-Equivariant Neural Density Functional Theory for Three-Dimensional Lattice Fluids arXiv:2608.08137 ⓘ · analyzed Sep 1, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Constrain the first convolutional layer, or every convolutional layer, by averaging each kernel over the 48 rotations and reflections of the cubic point group. A scalar 3D field then receives exactly the same prediction after any lattice rotation or reflection, eliminating the need to learn equivalent crystallographic orientations from separate examples.

Formulas

$$K_{\mathrm{eq}}(\mathbf{u})=\frac{1}{|G|}\sum_{g\in O_h}K(g\mathbf{u}),\qquad |O_h|=48.$$
$$y(\mathbf{r})=\sum_{\mathbf{u}\in\mathcal{N}}K_{\mathrm{eq}}(\mathbf{u})x(\mathbf{r}+\mathbf{u}),\qquad y[gx](\mathbf{r})=y[x](g^{-1}\mathbf{r}).$$
$$P_R=\frac{1}{48}\sum_{g\in O_h}D_R(g)\otimes T_g,\qquad P_R^2=P_R.$$

Mathematical statement

Let G=O_h be the 48-element cubic point group, let K:Z^3 to R^(C_out times C_in) be an unconstrained convolution kernel, and let g u denote the lattice coordinate obtained by applying g in G to offset u. Define the group-averaged kernel K_eq(u)=|G|^(-1) sum over g in G of K(g u). For a scalar input field x and output y(r)=sum over u of K_eq(u)x(r+u), the output is invariant under simultaneous cubic transformation of the input coordinates: y[g x](r)=y[x](g^(-1)r), where (g x)(r)=x(g^(-1)r). For feature channels carrying nontrivial representations, replace the simple average by the projector P_R=|G|^(-1) sum over g in G of D_R(g) tensor T_g, where D_R(g) is the channel representation and T_g permutes kernel offsets.

Implementation notes

Integrate this at the first 3D convolution of a dense CNN, U-Net, neural operator, or lattice world model. For a scalar-density baseline, store one learnable kernel K with offsets in a cubic neighborhood and construct K_eq on every forward pass by applying the 48 integer coordinate permutations and sign flips, summing, and dividing by 48; use ordinary pointwise nonlinearities afterward. For a stronger version, use representation-valued channels: classify channels as scalar, vector, or tensor types, apply the projector P_R to the tensor formed from channel indices and spatial offsets, and use only equivariant linear maps between types. Pseudocode is: sample x; for each offset u set K_eq[u]=mean(K[g(u)] for g in G); y=conv(x,K_eq); y=activation(y). The group action, orbit list, and averaging rule are taken directly from the paper; the only empirical quantities are the learned kernel weights and validation error. First run a cheap synthetic test on 32^3 voxel fields generated from randomly rotated anisotropic Gaussian blobs or cubic obstacle patterns. Compare an unconstrained CNN, a six-orientation augmentation baseline, and the averaged CNN at equal parameter count and training examples. Measure equivariance error E_eq=mean_g ||f(gx)-g f(x)||_2/||f(x)||_2 and prediction error. The quantitative prediction is E_eq at numerical precision, typically below 1e-6 in float32 apart from boundary effects, while the unconstrained model has nonzero error; with only one-sixth to one-twelfth of the orientation coverage, the equivariant model should retain the augmented baseline's accuracy within 10 percent. On lattice-fluid data, compare wall profiles and anisotropic pair correlations separately by crystallographic direction.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Inconclusive

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a readable NumPy/PyTorch MVP for cubic-group kernel averaging over all 48 signed coordinate permutations. The mechanism manifested: projection idempotence and within-orbit spread were both 6.66e-16, averaged-convolution equivariance errors were 2.5e-16–1.25e-15 across the sweep, and unconstrained error increased from 0.027 at asymmetry 0.01 to 35.02 at 10. The orbit-count prediction also matched the measured values (radii 0–3: 1, 4, 10, 20); the tiny classifier tied the baseline at 1.0 accuracy, so no accuracy win was demonstrated.

Agent confidence
8/10
Baseline
Equivariance error: 2.68e-16, 0.0272, 0.486, 3.88, 35.0 for sigma 0, 0.01, 0.1, 1, 10; test accuracy 1.0; 242 parameters.
Idea
Averaged equivariance error: 2.53e-16, 2.62e-16, 2.56e-16, 3.13e-16, 1.25e-15; projection idempotence 6.66e-16; orbit spread 6.66e-16; test accuracy 1.0; 242 parameters.

Limitations: Only scalar channels and a single averaged first-layer-style convolution were implemented. Representation-valued projectors, six-orientation augmentation, non-periodic boundaries, larger datasets, speed/FLOP measurements, and crystallographic or lattice-fluid benchmarks were not tested. The tiny classifier saturated, so tied accuracy does not establish a sample-efficiency gain.

How to run: python3 experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.08137)

Ahead of the baseline (−6.9%) but not statistically significant (p=0.2532, wins 3 / 8 paired seeds).

Benchmark
Cubic_blob_orientation
Model
tiny3d_shared_architecture
Paired seeds
8
Baseline mean
0.3078
Idea mean
0.2867
Effect (Δ)
-0.0211 (−6.9%; negative = idea better)
Wins
3 / 8 paired seeds
p-value
0.2532 (permutation test, 20 000 shuffles)
Smallest detectable effect
±12.9%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

The task is synthetic 3D voxel data rather than crystallographic or lattice-fluid data. Only scalar first-layer averaging was tested; all-layer averaging, representation-valued channels, boundary handling, and FLOP benchmarking were not tested.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 9/10

Implemented and ran the full custom 3D convolution benchmark with 8 paired seeds, tuned baseline and idea sweeps, and a trained-model mechanism signature. The idea lowered mean error from 0.3078125 to 0.2867188, but the paired permutation p-value was 0.25325, so there was no significant win under the benchmark criterion.

Baseline
Mean test error 0.3078125; best lr=0.012, epochs=4.
Idea
Mean test error 0.2867188; paired delta=-0.0210938; 3/8 wins; permutation p=0.25325; mechanism max equivariance error=0.0859135, confirmed=false.

Benchmark result

Ahead of the baseline (−6.9%) but not statistically significant (p=0.2532, wins 3 / 8 paired seeds).

Benchmark
Cubic_blob_orientation
Model
tiny3d_shared_architecture
Paired seeds
8
Baseline mean
0.3078
Idea mean
0.2867
Effect (Δ)
-0.0211 (−6.9%; negative = idea better)
Wins
3 / 8 paired seeds
p-value
0.2532 (permutation test, 20 000 shuffles)
Smallest detectable effect
±12.9%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

The task is synthetic 3D voxel data rather than crystallographic or lattice-fluid data. Only scalar first-layer averaging was tested; all-layer averaging, representation-valued channels, boundary handling, and FLOP benchmarking were not tested.

How to run: python3 stage2_bench.py

Artifacts

Implementation overview ⬇ Download all as ZIP 7 files · code, reports and structured results