Mechanism confirmed, baseline not beaten 2026

Fundamental-Cycle Compatibility Basis

Usefulness7/10
Difficulty5/10
Novelty8/10

Source paper: On the Complexity of the Compatibility Problem for Succinctly Encoded Conditional Distributions arXiv:2608.31120 · analyzed Sep 2, 2026

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

Idea description

For sparse conditional supports, replace enumeration of all possible four-cycles with a graph-theoretic cycle basis. Construct the bipartite support graph, choose a spanning forest, and penalize one residual for each non-tree edge and its induced fundamental cycle. In log space, every other cycle constraint is a linear combination of these basis constraints, yielding a principled sparse regularizer.

Formulas

$$a_{xy}=\log q_\theta(x|y)-\log r_\phi(y|x)$$
$$a_{xy}=u_x-v_y\quad\Longrightarrow\quad \sum_{(x,y)\in C}s_{xy}a_{xy}=0\ \text{for every closed cycle }C$$
$$\dim\mathcal{C}(G)=|E|-|V|+C$$
$$R_{\mathrm{basis}}=\sum_{e\in E\setminus T}\rho\left(\sum_{(x,y)\in C_e}s_{xy}a_{xy}\right)$$

Mathematical statement

Let G=(V,E) be the bipartite support graph: V contains all X-values and Y-values, and an edge (x,y) belongs to E when both conditional probabilities on that pair are positive or allowed by the support mask. Define the edge field a_xy = log q_theta(x|y) - log r_phi(y|x). If the conditionals come from a compatible joint with positive margins, then a_xy = u_x - v_y for node potentials u_x and v_y. Consequently, the signed sum of a_xy around every closed graph cycle C is zero. If G has |V| vertices, |E| edges, and C connected components, its cycle-space dimension is |E|-|V|+C. Choose a spanning forest T. Each non-tree edge e creates a fundamental cycle C_e by adding e to the unique path in T joining its endpoints. Penalize R_basis = sum over non-tree edges of rho(sum over cycle edges of s_xy a_xy), where s_xy is +1 or -1 according to the orientation of that edge in the cycle and rho is squared or Huber loss. Vanishing on a cycle basis implies vanishing on every cycle because cycle sums are additive over the graph cycle space.

Implementation notes

Integrate this as a sparse-support regularizer for graph generative models, constrained discrete diffusion, masked categorical transformers, or bidirectional imputers. Build the bipartite graph G from the known legality mask or empirical nonzero transitions. Compute a spanning forest with DFS or union-find. For each edge not in the forest, store the tree path connecting its endpoints and the orientation sign of every edge in the resulting fundamental cycle. During each forward pass, compute log-softmax probabilities only on allowed edges, form a_xy = log_q[x,y] - log_r[y,x], and evaluate each stored signed path sum. Pseudocode: T, non_tree = spanning_forest(G); cycles = [tree_path(e.u,e.v)+[e] for e in non_tree]; a = log_q - log_r; residual[e] = sum(sign(edge,cycle)*a[edge] for edge in cycle); loss = task_loss + lambda * mean(huber(residual)); update both networks. The support graph, forest, cycle paths, and cycle rank |E|-|V|+C are computed exactly; only neural probabilities are estimated. First use synthetic sparse n-by-n conditionals with chain, grid, and random supports. Compare exhaustive cycle enumeration, random cycle sampling, the basis method, and no regularizer at equal steps and model size. Measure regularizer wall-clock time, held-out residuals over randomly generated cycles, and recovery error for a known compatible joint. Pre-register that the basis should match exhaustive constraints within 5% in held-out 95th-percentile residual while using only |E|-|V|+C constraints, and should provide at least 2x lower regularizer time on sparse graphs. Include random equal-count cycles as an ablation. Falsification occurs if basis residuals vanish but unseen cycle residuals remain large, or if its cost is not lower than exhaustive enumeration at the intended sparsity.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: No measurable effect

Stage 1 — Mechanism check agent confidence 8/10

Built a spanning-forest fundamental-cycle basis for bipartite support graphs, with correctly oriented signed cycle coefficients, cycle-rank verification, exhaustive simple-cycle comparison, and compatible/perturbed edge-field checks. Compatible node-potential fields produced near-zero residuals for both basis and exhaustive cycles (maximum about 2e-15), while the basis used exactly the cycle rank and was 68x–2520x faster than exhaustive evaluation in the tested graphs. This validates the mathematical and computational claim, but not downstream neural-network training gains.

Agent confidence
8/10
Baseline
Exhaustive simple-cycle evaluation: 110–5000 cycles; wall time 0.00290–0.24937 sec per 10 evaluations; perturbed-field 95th-percentile residual 0.472–0.706.
Idea
Fundamental basis: 10–41 constraints equal to |E|-|V|+C; wall time 0.000043–0.000175 sec per 10 evaluations; speedups 68x–2520x; compatible-field maximum residual 2.2e-16–5.6e-16.

Limitations: No neural conditional models, optimization, held-out data, GPU execution, Huber loss, or task-loss comparison was tested. Exhaustive cycle enumeration is capped at 5000 cycles for dense supports, and timing is a small NumPy regularizer-cost proxy rather than an end-to-end training benchmark.

How to run: python3 experiment.py

Stage 2 — Benchmark vs. tuned baseline

No significant difference vs. the tuned baseline (−-0.0%, p=1, wins 0 / 8 paired seeds).

Benchmark
Sparse_cycle_compatibility
Model
pair_mlp
Paired seeds
8
Baseline mean
0.4884
Idea mean
0.4884
Effect (Δ)
0 (−-0.0%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
1 (permutation test, 20 000 shuffles)
Smallest detectable effect
±0.0%
Mechanism
Confirmed ✓
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

The registered task is small and synthetic rather than a production masked transformer or diffusion model. The baseline sweep covered learning rate but not weight decay; training used 18 epochs and 400 training/test samples. No larger graph or end-to-end transformer was tested.

How to run: python3 run_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

The accepted and registered sparse_cycle_compatibility track was evaluated with 8 paired seeds and a tuned baseline learning-rate sweep. The fundamental-cycle rank and trained-model mechanism checks passed, but the best regularized system exactly matched the baseline held-out error, with delta_mean=0 and permutation p=1.0; therefore the idea did not win.

Baseline
Mean err 0.4884374812 ± 0.0730869185; best lr=0.01.
Idea
Mean err 0.4884374812 ± 0.0730869185; best lambda=0.01 at lr=0.01; paired delta=0, p=1.0.

Benchmark result

No significant difference vs. the tuned baseline (−-0.0%, p=1, wins 0 / 8 paired seeds).

Benchmark
Sparse_cycle_compatibility
Model
pair_mlp
Paired seeds
8
Baseline mean
0.4884
Idea mean
0.4884
Effect (Δ)
0 (−-0.0%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
1 (permutation test, 20 000 shuffles)
Smallest detectable effect
±0.0%
Mechanism
Confirmed ✓
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

The registered task is small and synthetic rather than a production masked transformer or diffusion model. The baseline sweep covered learning rate but not weight decay; training used 18 epochs and 400 training/test samples. No larger graph or end-to-end transformer was tested.

How to run: python3 run_bench.py

Artifacts

⬇ Download all as ZIP 6 files · code, reports and structured results