Fundamental-Cycle Compatibility Basis
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
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
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
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
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
- bench_report.json 2.3 KB View Raw JSON
- custom_cycle_track.py 1.2 KB View Raw JSON
- experiment.py 6.5 KB View Raw JSON
- report.md 1.5 KB View
- report_bench_2026-09-02T123039.md 3.8 KB View
- run_bench.py 7.1 KB View Raw JSON