Unverified 2026

Four-Root Ternary Mixer

Implementation & benchmark of arXiv:2607.06795 — On $η$-periodic Formal Ternary Laws

Usefulness5/10
Difficulty4/10
Novelty7/10

Source paper: On $η$-periodic Formal Ternary Laws arXiv:2607.06795 ⓘ · analyzed Aug 30, 2026

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

Idea description

Replace a generic three-input concatenation MLP with a permutation-symmetric mixer built from the four signed combinations x+y-z, x-y+z, -x+y+z, and -x-y-z. Apply a shared truncated exponential to these combinations and aggregate symmetric pairwise products, producing controlled quadratic and higher-order interactions without materializing a full trilinear tensor.

Formulas

$$t_{1}=x^{H}+y^{H}-z^{H},\quad t_{2}=x^{H}-y^{H}+z^{H},\quad t_{3}=-x^{H}+y^{H}+z^{H},\quad t_{4}=-x^{H}-y^{H}-z^{H}.$$
$$h(F_{2})=\sum_{i<j}\exp(t_{i})\exp(t_{j}).$$
$$\exp(u)\exp(v)\equiv uv+\sum_{n=1}^{\infty}a_{n}\left(u^{n+1}v+uv^{n+1}\right)\quad\text{modulo decomposables}.$$
$$\widetilde{F}_{2}(x,y,z)=\sum_{1\leq i<j\leq4}E_{K}(t_i)E_{K}(t_j),\qquad E_K(s)=\sum_{r=0}^{K}\frac{s^r}{r!}.$$

Mathematical statement

The paper defines four roots of a formal ternary law using t_1=x^H+y^H-z^H, t_2=x^H-y^H+z^H, t_3=-x^H+y^H+z^H, and t_4=-x^H-y^H-z^H, where x^H, y^H, and z^H are logarithmic coordinates for three inputs. It forms symmetric expressions in their exponentials, including h(F_2)=sum_{i<j} exp(t_i) exp(t_j). The proof also uses exp(u) exp(v) congruent to uv plus the sum over n>=1 of a_n times (u^(n+1)v + uv^(n+1)) modulo decomposable terms, and establishes sum_{i<j} t_i t_j = -2((x^H)^2+(y^H)^2+(z^H)^2). Here i and j range from 1 to 4, a_n are formal power-series coefficients, and u and v are scalar formal coordinates. The neural adaptation replaces scalar formal variables by projected feature vectors, truncates the exponential at degree K, and learns the projection and output maps while preserving the signed-root and symmetric-pair structure.

Implementation notes

(1) Integration point: use this module as a replacement for a three-input fusion MLP. In a graph neural network, let x, y, and z in R^d be a center-node state and two sampled neighbor states. In a transformer, they can be three routed token features or three expert outputs. Apply LayerNorm and a shared projection P in R^(d by m), obtaining u=P norm(x), v=P norm(y), and w=P norm(z). Compute the four signed roots elementwise: t1=u+v-w, t2=u-v+w, t3=-u+v+w, and t4=-u-v-w. (2) Pseudocode: u,v,w = P(norm(x)), P(norm(y)), P(norm(z)); T = [u+v-w, u-v+w, -u+v+w, -u-v-w]; E[j] = sum(r=0..K, T[j]^r / factorial(r)); q = sum(i<j, E[i] * E[j]); h = W_out GELU(q) + W_skip x. The tensor q is the adapted truncated version of the paper's h(F_2). Start with K=2 or K=3. For numerical stability, use E_K(t_j divided by tau), where tau is a learned positive channelwise temperature initialized to 2. (3) The signed-root pattern and symmetric pair sum are taken from the paper; P, W_out, W_skip, and tau are learned. Estimate computational cost analytically from four evaluations of a degree-K polynomial and six elementwise products, and compare it with the baseline MLP at matched FLOPs. Test permutation invariance by randomly permuting the three inputs during training and evaluating all six permutations at validation time. (4) First cheap experiment: train a small graph network on ZINC, or a three-stream MLP on the synthetic target f(x,y,z)=sum_k x_k y_k z_k with added pairwise distractors. Compare K=2, 3, and 4 against a parameter-matched concatenation-plus-two-layer-MLP baseline. Success means lower validation error at equal parameters and FLOPs, or equal accuracy with at least 20 percent fewer parameters. Also record gradient norms and activation maxima; the truncated construction should avoid the instability of an unconstrained learned trilinear tensor.

Verification

This idea has not been verified yet.

Verification happens in two stages: Stage 1 — a mechanism check on a toy system confirms the claimed mathematical phenomenon reproduces; Stage 2 — a benchmark implements the idea on a real (small) neural network task and compares it against a tuned baseline over 8 paired seeds with a permutation test.

Artifacts

Artifacts unavailable.