✗ Failed on benchmark 2026

Fractional Cube Spectral Penalty

Implementation & benchmark of arXiv:2606.31961 — A Beckmann boundary form of Talagrand's conjecture on the discrete cube

Usefulness7/10

Difficulty4/10

Novelty8/10

Regularization Generalization Stability Accuracy Loss Regularization Mlp Graph nn Harmonic analysis Spectral theory Probability Functional analysis

Source paper: A Beckmann boundary form of Talagrand's conjecture on the discrete cube arXiv:2606.31961 ⓘ · analyzed Aug 29, 2026

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

Idea description

Add a fractional Laplacian penalty to neural functions over binary inputs so that high-order coordinate interactions are damped according to $|S|^\alpha$, rather than treating all Fourier degrees equally. The penalty is estimated with random continuous-time bit-flip perturbations, requiring only extra forward passes and no explicit Fourier transform. It is especially suited to models that overfit through high-order Boolean interactions while retaining useful low-order structure.

Formulas

$$\sum_{S\neq\varnothing}|S|^{\alpha}\widehat{\mathbf{1}_{A}}(S)^{2}\lesssim_{\alpha}\mathbb{E}\,\omega_{\alpha}(h_A),$$

$$\omega_{\alpha}(m)=\begin{cases}\sqrt m,&0<\alpha<1/2,\\\sqrt m\log(e+m),&\alpha=1/2,\\m^{\alpha},&1/2<\alpha<1,\end{cases}$$

$$\mathcal{E}_{\alpha}(f)=\sum_{S\neq\varnothing}|S|^{\alpha}\widehat f(S)^2,$$

$$\mathcal{E}_{\alpha}(f)=\frac{\alpha}{2\Gamma(1-\alpha)}\int_0^\infty \mathbb{E}_{x,z_t}\!\left[(f(x)-f(z_t))^2\right]t^{-1-\alpha}\,dt,$$

Mathematical statement

For $A\subset\{-1,1\}^n$, let $h_A(x)=\#\{i:x\in A,\ x^{\oplus i}\notin A\}$ be the one-sided boundary degree. If $\widehat{\mathbf{1}_A}(S)$ are Walsh-Fourier coefficients indexed by $S\subseteq[n]$, the paper proves for $0<\alpha<1$ that $\sum_{S\neq\varnothing}|S|^\alpha\widehat{\mathbf{1}_A}(S)^2\lesssim_\alpha\mathbb{E}\omega_\alpha(h_A)$, with $\omega_\alpha(m)=\sqrt m$ for $\alpha<1/2$, $\omega_{1/2}(m)=\sqrt m\log(e+m)$, and $\omega_\alpha(m)=m^\alpha$ for $\alpha>1/2$. The left side is the fractional spectral energy of the indicator. For a real neural output $f_\theta$, use the same spectral multiplier on its centered Walsh expansion. It can be estimated without computing coefficients through the continuous-time coordinate-flip semigroup $P_t$, whose eigenvalue on Walsh degree $|S|$ is $e^{-t|S|}$, together with $\lambda^\alpha=\frac{\alpha}{\Gamma(1-\alpha)}\int_0^\infty(1-e^{-t\lambda})t^{-1-\alpha}\,dt$.

Implementation notes

Insert the penalty after the model produces a scalar logit f_theta(x) or a classwise logit vector. For each minibatch x, sample K continuous times t_j on a log-uniform interval [t_min,t_max], and generate z_{t_j} by independently flipping each input bit with probability p_j=(1-exp(-2t_j))/2; this is the coordinate-flip semigroup with eigenvalue exp(-t_j|S|) under the paper's generator convention. Estimate the fractional energy with a truncated quadrature: R_alpha = alpha/(2 Gamma(1-alpha)) sum_j q_j t_j^(-1-alpha) mean_x[(f_theta(x)-f_theta(z_tj))^2], where q_j are log-space quadrature weights. Center f over the minibatch before computing differences if the constant component should be excluded. Add lambda_alpha R_alpha to the task loss. Use alpha=0.25, 0.5, and 0.75 as separate ablations; alpha<1/2 gives a square-root boundary profile, alpha=1/2 includes the logarithmic correction, and alpha>1/2 emphasizes larger interaction orders more strongly. The exact mathematical calculation is the Fourier multiplier |S|^alpha; the implementation estimates it through Monte Carlo semigroup perturbations and finite time truncation. As a cheap first experiment, train a 3-layer MLP on parity/XOR mixtures and on MNIST with randomly selected binary pixel patches, comparing ordinary weight decay, a one-bit consistency loss, and this fractional penalty at equal forward-pass budgets. Track clean accuracy, accuracy under k-bit flips for k=1,2,4,8, empirical Walsh energy by enumerating subsets for n<=16, and train-test generalization. The expected signal is reduced high-order Fourier energy and improved multi-bit corruption accuracy with no degradation on low-order tasks; a useful result would be equal clean accuracy with substantially better k-bit corruption accuracy.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: No measurable effect

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

Stage 1 — Mechanism check agent confidence 7/10

Built a fractional cube spectral penalty using random bit-flip semigroup perturbations, together with exact Walsh-transform and numerical quadrature checks. The mechanism manifested: pure degree-d Walsh modes followed the predicted d^alpha law exactly, semigroup quadrature matched exact energy within 3.5–15.8%, and Monte Carlo standard deviation fell from 0.568 to 0.274 as K increased from 4 to 64. On the parity-mixture toy task, the penalty improved 1/2/4/8-bit corruption MSE, especially for alpha=0.75, but substantially worsened clean MSE, so this is a robustness signal rather than an overall win.

Agent confidence: 7/10

Baseline: Clean MSE 0.00646; flip MSE for k=1/2/4/8: 1.080/1.666/2.347/1.651.
Idea: alpha=0.75: clean MSE 0.12678; flip MSE for k=1/2/4/8: 0.816/1.297/1.850/1.301. Exact degree-law prediction matched for d=1,2,4,6,8 and all tested alpha; semigroup relative errors were 15.8%, 3.5%, and 13.5% for alpha=.25,.5,.75.

Limitations: Only one fixed random seed and one small synthetic parity task were tested; no MNIST, classwise logits, one-bit consistency baseline, hyperparameter tuning, or equal-forward-pass-budget accounting was performed. The Monte Carlo estimator showed decreasing variance but noticeable finite-truncation/sampling bias, and regularizer strength was not tuned to preserve clean accuracy.

How to run: python3 experiment.py

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

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

Benchmark: Binary interactions
Model: mlp_tiny
Paired seeds: 8
Baseline mean: 0.2991
Idea mean: 0.3014
Effect (Δ): 0.0023 (+0.8%; negative = idea better)
Wins: 3 / 8 paired seeds
p-value: 0.6974 (permutation test, 20 000 shuffles)
Smallest detectable effect: n/a
Mechanism: Not confirmed ✗
Practical effect: No effect
Baseline tuning: swept over 3 configs

Limitations:

Only the structurally matched registered binary_interactions track was tested. The mechanism probe used four representative seeds and degree-2/degree-6 Walsh projections; alpha was fixed at 0.75 and the estimator used finite Monte Carlo semigroup quadrature.

How to run: python3 bench_fractional.py

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

Stage 2 — Benchmark Aug 30, 2026 latest Failed ✗

Agent confidence: 9/10

The Fractional Cube Spectral Penalty was implemented as a semigroup bit-flip regularizer and evaluated on the registered custom bench track binary_interactions with the same mlp_tiny architecture and paired data. The tuned baseline achieved mean test MSE 0.29906084 versus 0.30135944 for the best idea setting, with paired delta +0.00229860 and permutation p=0.69735, so there was no significant win. The trained-model Walsh signature also failed to confirm suppression: degree-6/degree-2 response was 0.0032243 for baseline versus 0.0035361 for the idea.

Baseline: Mean test MSE 0.2990608402, std 0.0349013276; best lr=0.006, weight_decay=0.0001.
Idea: Mean test MSE 0.3013594449, std 0.0351211661; best lr=0.006, weight_decay=0.0001; paired delta +0.0022986047; 3/8 wins; p=0.69735.

Benchmark result