✗ Failed on benchmark 2026

Gauge-Covariant Wilson-Loop Regularization

Implementation & benchmark of arXiv:2608.17817 — Frustration without Glass: A Non-Abelian Gauge Model of Network Compatibility

Usefulness7/10

Difficulty6/10

Novelty7/10

Architecture Stability Generalization Accuracy Graph nn Regularization Training dynamics Statistical mechanics Geometry Graph theory Linear algebra

Source paper: Frustration without Glass: A Non-Abelian Gauge Model of Network Compatibility arXiv:2608.17817 ⓘ · analyzed Sep 1, 2026

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

Idea description

Attach an SU(2) transport matrix to every directed edge of a graph neural network and penalize nontrivial plaquette holonomies instead of penalizing individual edge transformations. The regularizer is invariant to arbitrary local changes of latent representation frame, encouraging path-consistent relational features without requiring all edges to share one global coordinate system.

Formulas

U_ij ∈ SU(2), U_ji = U_ij†, U_ij -> h_i U_ij h_j†, h_i ∈ SU(2).

H_ijk = U_ij U_jk U_ki, H_ijk -> h_i H_ijk h_i†, M_P = (1 / |F|) sum over faces f of ReTr(H_f) / 2.

E_F = (1 / |F|) sum over faces f of J_f [1 - ReTr(H_f) / 2], L = L_task + lambda E_F.

chi_P = |F| [average(M_P squared) - average(M_P) squared], sigma_c(L) = argmax over sigma of chi_P(L,sigma).

Mathematical statement

Let G=(V,E,F) be a graph with triangular faces F. Let U_ij belong to SU(2) and represent transport from node j to node i, with U_ji equal to the Hermitian conjugate of U_ij. A local gauge transformation maps U_ij to h_i U_ij h_j dagger, where h_i belongs to SU(2). The triangular plaquette holonomy is H_ijk = U_ij U_jk U_ki. It transforms by conjugation, so its real trace is gauge invariant. Define compatibility M_P as the mean normalized real trace of all plaquette holonomies. The Wilson frustration energy penalizes deviations from the preferred identity holonomy. A disorder sweep predicts a susceptibility peak at the transition from globally compatible to frustrated correlated representations.

Implementation notes

Integrate the mechanism into a message-passing GNN. For each directed edge, use an MLP on the endpoint features and edge attributes to output four real numbers, normalize them to a unit quaternion, and convert that quaternion into a 2 by 2 SU(2) matrix. Set the reverse-edge matrix to the Hermitian conjugate. For sampled triangular faces, compute the ordered product of the three edge matrices and add the Wilson energy to the task loss. Pseudocode is: q = normalize(edge_mlp(x_i, x_j, e_ij)); U_ij = quaternion_to_su2(q); U_ji = dagger(U_ij); H = U_ij @ U_jk @ U_ki; loop_loss = mean(J * (1 - real_trace(H) / 2)); loss = task_loss + lambda * loop_loss; backward(loss). Use the transport in messages through m_ij = U_ij @ z_j, or concatenate the equivalent quaternion action with scalar features. The gauge-covariance identities are analytic; lambda, the plaquette couplings J, and the critical disorder are empirical. The first cheap experiment should use a 20-node triangulated random geometric graph and synthetic node labels generated from a planted global transport frame. Compare a standard GNN, an unconstrained transport GNN, and this regularized model while sweeping the standard deviation sigma of random J. Measure M_P, task accuracy, and chi_P over several seeds and graph sizes. The quantitative prediction is a continuous compatibility transition: M_P should fall rapidly near sigma_c, chi_P should peak there, and the peak should shift weakly with graph size. Randomly rotate every node latent frame at train and test time; the gauge model should retain accuracy, while a non-covariant baseline should degrade. Excessive lambda should drive M_P toward one and cause feature oversmoothing.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not tested

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 self-contained quaternion/SU(2) Wilson-loop implementation with gauge transformations, plaquette compatibility, frustration energy, disorder sweeps, and a regularized toy optimization. The mechanism manifested: gauge-conjugation error was 1.0e-15, pure-gauge loops had M_P=1 with energy below 8e-16, and the predicted disorder law M_P=exp(-3 sigma^2/2) matched with maximum absolute error 0.0028. Mild regularization improved task MSE from 0.0508 to 0.0383 while reducing loop energy from 0.3400 to 0.1730; stronger regularization increased compatibility but removed the task benefit.

Agent confidence: 8/10

Baseline: lambda=0: task MSE 0.05083, loop energy 0.34002
Disorder scaling: For predicted E[M_P]=exp(-1.5 sigma^2), maximum absolute error over sigma=0..0.9 was 0.00280
Gauge covariance: Maximum transformed-loop quaternion error 9.99e-16
Idea: lambda=0.1: task MSE 0.03827, loop energy 0.17298; lambda=0.5: task MSE 0.04343, loop energy 0.03455; lambda=1.0: task MSE 0.05044, loop energy 0.01200
Pure gauge flatness: Observed M_P=1.000000 and maximum energy 7.77e-16
Regularization effect: Loop energy decreased monotonically with lambda, while task MSE improved at mild regularization and degraded at excessive regularization

Limitations: The baseline comparison is a small local-angle optimization rather than a full message-passing GNN on a triangulated graph. No train/test latent-frame randomization, graph-size sweep, CUDA experiment, or empirical susceptibility peak near a phase transition was tested.

How to run: python3 wilson_experiment.py

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

Ahead of the baseline (−38.5%) but not statistically significant (p=0.2182, wins 6 / 8 paired seeds).

Benchmark: Holonomy_cycle_sector
Model: custom_transport_cycle
Paired seeds: 8
Baseline mean: 0.0244
Idea mean: 0.015
Effect (Δ): -0.0094 (−38.5%; negative = idea better)
Wins: 6 / 8 paired seeds
p-value: 0.2182 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±63.8%
Mechanism: n/a
Practical effect: Inconclusive
Baseline tuning: swept over 6 configs

Limitations:

The available matched track uses an 8-edge cycle and binary U(1)-style planted sectors rather than triangular SU(2) plaquettes on a general graph, so the experiment tests transfer of the Wilson-loop principle but not the full proposed GNN setting. No graph-size sweep, latent-frame randomization, or disorder susceptibility curve was run. The mechanism signature's confirmed flag reflects measured trained-model frustration reduction and algebraic sanity checks, not a statistically confirmed accuracy gain.

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 Sep 1, 2026 latest Failed ✗

Agent confidence: 9/10

Implemented an end-to-end SU(2) quaternion transport classifier on the structurally matched holonomy cycle track, with identical baseline and idea architectures and Wilson-loop loss as the only intervention. The idea achieved mean test error 0.0150 versus baseline 0.0244, with 6/8 paired wins and delta -0.009375, but the paired permutation p-value was 0.2182, so this is not a significant win under the benchmark protocol. The trained model showed compatibility M=0.8123 and Wilson energy 0.1877; the covariance/flatness sanity check passed numerically, but this mechanism signal does not override the nonsignificant task result.

Baseline: holonomy_cycle_sector; best lr=0.006, weight_decay=0.0, epochs=8; full mean error=0.0243749991, per-seed=[0.0500,0.0200,0.0150,0.0300,0.0150,0.0100,0.0250,0.0300]
Idea: Wilson lambda=0.1, lr=0.006, weight_decay=0.0, epochs=8; full mean error=0.0149999995, per-seed=[0.0050,0.0150,0.0100,0.0100,0.0150,0.0050,0.0450,0.0150]; delta=-0.0093749996; p=0.2182
Mechanism signature: trained seed-0 compatibility M=0.8122859, Wilson energy=0.1877141; quaternion conjugation max error=3.58e-7 and pure-gauge flat-loop scalar=1.0; signature confirmed=true for the observed compatibility/frustration effect, not for task improvement

Benchmark result