△ Mechanism confirmed, baseline not beaten 2026

Binary-form symmetric-power equivariant layer

Implementation & benchmark of arXiv:2607.07150 — On 4-dimensional convex projective domains invariant by a lattice of $\mathrm{SL}_2 (\mathbb{R})$

Usefulness6/10

Difficulty5/10

Novelty6/10

Architecture Accuracy Sample efficiency Generalization Cnn Graph nn Transformer Embedding Representation theory Lie groups Linear algebra Algebra

Source paper: On 4-dimensional convex projective domains invariant by a lattice of $\mathrm{SL}_2 (\mathbb{R})$ arXiv:2607.07150 ⓘ · analyzed Aug 30, 2026

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

Idea description

Replace an unconstrained feature vector of size n+1 by the coefficients of a homogeneous degree-n binary polynomial and make the layer transform through the irreducible symmetric-power representation of GL_2(R). For n=4 this creates a five-channel equivariant feature block whose transformation law is exact rather than learned through augmentation.

Formulas

$$\rho\left(\begin{smallmatrix}a&b\\c&d\end{smallmatrix}\right)\cdot P(X,Y)=P\left((X,Y)\cdot\left(\begin{smallmatrix}a&b\\c&d\end{smallmatrix}\right)\right)=P(aX+cY,bX+dY).$$

$$P(X,Y)=\sum_{k=0}^{n}p_kX^{n-k}Y^k,\qquad [R_n(A)p]_j=[X^{n-j}Y^j]P(aX+cY,bX+dY).$$

$$R_n(A)_{jk}=[X^{n-j}Y^j](aX+cY)^{n-k}(bX+dY)^k,\qquad F(Ax)=R_n(A)F(x).$$

Mathematical statement

The paper identifies R^(n+1) with the vector space V_n of homogeneous polynomials P(X,Y) of degree n and defines the representation rho:GL_2(R) to GL(V_n) by rho(A)P(X,Y)=P((X,Y)A). For A=[[a,b],[c,d]], this is P(aX+cY,bX+dY). If P(X,Y)=sum_{k=0}^n p_k X^(n-k)Y^k, the transformed coefficient vector is obtained by polynomial expansion. Define R_n(A)_{jk} as the coefficient of X^(n-j)Y^j in (aX+cY)^(n-k)(bX+dY)^k. The exact equivariance condition is F(Ax)=R_n(A)F(x), where x is an input with a two-dimensional linear coordinate action and F(x) is a V_n-valued feature. The transferable asset is the explicit finite-dimensional representation matrix, not a generic learned approximation.

Implementation notes

(1) Integration point: add this as an embedding block in a CNN, graph neural network, or transformer whenever each token, node, or local patch has a two-dimensional coordinate or planar geometric feature. Start with degree n=4, using coefficient order [X^4,X^3Y,X^2Y^2,XY^3,Y^4]. (2) Pseudocode: given input coordinates x and a sampled transformation A, construct the coefficient matrix R4(A) by expanding each basis polynomial (aX+cY)^(4-k)(bX+dY)^k; encode each local object as p; apply a shared linear map q=W p across locations; transform the input and independently compute q_transformed=W R4(A)p. For multiple copies of the representation, use q=(W_copy tensor I_5)p and apply the same R4(A) to every copy. Avoid ordinary biases unless they are placed in scalar invariant channels. (3) Compute R4(A) exactly from the displayed polynomial formula. Estimate only ordinary network weights and nonlinear gates empirically. For nonlinearities, use scalar gates shared across the five channels or couple several representation copies, rather than applying independent coordinatewise nonlinearities that break equivariance. (4) First experiment: train a small planar point-cloud or image classifier on randomly rotated and sheared inputs, comparing an MLP or CNN with augmentation against the equivariant layer at matched parameter count. Evaluate clean accuracy, accuracy under held-out transformations, and the relative equivariance error ||F(Ax)-R4(A)F(x)||/(||F(Ax)||+1e-8). Success is lower transformed-input error and near-zero equivariance error without requiring augmentation-heavy training.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

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 9/10

Built an exact degree-4 binary symmetric-power representation and a copy-mixing equivariant layer. Polynomial substitution and representation composition matched to about 1e-13, and the constrained layer had zero measured equivariance error versus order-one error for an unconstrained same-size layer. In the tiny classification test both the baseline MLP and invariant feature reached 1.00 accuracy, so the exact equivariance claim was validated but no accuracy win was observed.

Agent confidence: 9/10

Baseline: MLP test accuracy 1.000; median equivariance-control error 1.284
Idea: Symmetric-power layer median equivariance error 0.000; max polynomial relative error 3.75e-14; max composition error 7.47e-13; invariant classifier accuracy 1.000

Limitations: The learning comparison is a very small synthetic radius classification task, and the baseline already solves it perfectly. It does not test CNNs, point clouds, shears in a trained task, sample efficiency, FLOPs, or performance on a realistic dataset; the classifier uses a hand-derived invariant rather than a trained deep equivariant network.

How to run: python3 symmetric_power_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.07150) Sep 4, 2026

No significant difference vs. the tuned baseline (+74.4%, p=0.3091, wins 3 / 8 paired seeds).

Benchmark: Binary_symmetric_power_regression
Model: local_mlp_head
Paired seeds: 8
Baseline mean: 0.0046
Idea mean: 0.008
Effect (Δ): 0.0034 (+74.4%; negative = idea better)
Wins: 3 / 8 paired seeds
p-value: 0.3091 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±153.9%
Mechanism: Confirmed ✓
Practical effect: Inconclusive
Baseline tuning: swept over 3 configs

Limitations:

The benchmark uses a custom planar radial regression task rather than a built-in track because the built-ins lack the required planar-coordinate representation structure. The current intervention compresses the V4 block to a scalar invariant before the MLP head, rather than benchmarking multiple learned V4 representation copies with equivariant nonlinear gates. The mechanism signature numerically checks the trained model's feature computation, but does not test a full transformed-input prediction relation under arbitrary GL2 shears because the task target is only rotation invariant.

How to run: cd /home/maxwelhelp/all/math2nn/experiments/exp512_binary-form-symmetric-power-equivariant- && /home/maxwelhelp/main/bin/python3 bench_symmetric_power.py

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

Stage 2 — Benchmark Sep 4, 2026 latest Failed ✗

Agent confidence: 9/10

Implemented a local binary_symmetric_power_regression track and an end-to-end degree-4 symmetric-power model using the canonical train_model loop, with matched MLP heads and parity-preserving learning-rate sweeps. Polynomial substitution, representation composition, and the trained feature-map rotation check were near machine precision, confirming the mechanism numerically. However, the idea's mean test MSE was 0.00797 versus 0.00457 for the tuned baseline; paired delta was +0.00340 with permutation p=0.3091, so there was no significant win.

Baseline: mean test MSE 0.0045715 ± 0.0009398 over 8 seeds; best lr=0.01
Idea: mean test MSE 0.0079724 ± 0.0076998 over 8 seeds; lr=0.01
Math check: max polynomial error 4.26e-14; max composition error 1.14e-13; max rotation-invariant feature error 2.18e-11
Paired delta: +0.0034009 idea minus baseline; 3/8 idea wins; permutation p=0.3091

Benchmark result