△ Mechanism confirmed, baseline not beaten 2026

Support-Graph Parallel Scheduler

Implementation & benchmark of arXiv:2607.08841 — Partially-Commutative Polynomial Optimization

Usefulness7/10
Difficulty5/10
Novelty5/10

Source paper: Partially-Commutative Polynomial Optimization arXiv:2607.08841 ⓘ · analyzed Aug 30, 2026

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

Idea description

Convert a sequential modular network into parallel execution layers by placing mutually commuting operators in the same layer. The resulting circuit preserves all noncommuting precedence constraints while exposing safe concurrency and fusion opportunities for inference or training.

Formulas

$$C=(K_1,K_2,\ldots,K_k),\qquad K_i\subseteq X\text{ is a clique in }\mathcal G.$$
$$F(W;h):=\{x\in X:\ \forall i\in S_x,\ (w_i)_{h_i}=x\}.$$
$$h_i\leftarrow h_i+1\quad\text{for every }i\in S_x\text{ when }x\text{ is placed in the current layer}.$$
$$\operatorname{depth}(C)=\min\{k:C=(K_1,\ldots,K_k)\text{ respects all noncommuting precedence constraints}\}.$$

Mathematical statement

The paper represents a circuit as a sequence \(C=(K_1,K_2,\ldots,K_k)\) of vertical layers, where each \(K_i\subseteq X\) is a clique in the commutation graph \(\mathcal G\); operators in one layer commute and execute in parallel, while different layers execute sequentially. For a wire representation, each operator \(x\) acts on a support \(S_x\) consisting of the wires it touches. Given wire words \(W=(w_1,\ldots,w_m)\) and current head positions \(h=(h_1,\ldots,h_m)\), the paper defines the feasible set \(F(W;h)=\{x\in X:\forall i\in S_x,(w_i)_{h_i}=x\}\). Here \((w_i)_{h_i}\) is the first unconsumed operation on wire \(i\); an operation is feasible exactly when it is simultaneously visible on every wire it uses. Consuming all feasible operations forms the next parallel layer. The same construction can be applied to a neural computation graph, with wires representing disjoint channel groups, heads, tensor blocks, or device partitions. The depth of the resulting layered circuit is the critical-path execution depth, not the total number of operators.

Implementation notes

Integrate the scheduler into inference graph construction, after tracing a modular model but before kernel compilation. Partition the model state into explicit wires: channel groups for grouped convolutions or MLPs, attention heads for head-local projections, and separate feature blocks for block-diagonal linear layers. Represent each primitive operation \(x\) by its wire support \(S_x\) and by its occurrence in each wire word \(w_i\). Initialize head pointers \(h_i=1\). At each scheduling step compute \(F(W;h)=\{x:\forall i\in S_x,(w_i)_{h_i}=x\}\); put every element of \(F\) into the next layer if their supports are pairwise disjoint or if a backend-certified fused kernel exists. Advance all pointers on the supports of selected operators and repeat until all words are consumed. If multiple feasible operations share wires, choose the subset maximizing estimated kernel occupancy, or greedily select the largest support-disjoint set. Preserve the original order for every pair whose supports overlap. The scheduler computes feasibility from the paper’s head rule; kernel launch cost, memory bandwidth, and fusion benefit must be measured empirically. First test a 12-layer grouped MLP and a 4-head Transformer with head-local feed-forward modules on an NVIDIA GPU, comparing sequential execution against this scheduler at batch sizes 1 and 32. Measure critical-path latency, number of kernel launches, peak activation memory, and exact output agreement. The expected signal is reduced inference latency and launch count, with no measurable change in logits or perplexity.

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

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

Stage 1 — Mechanism check agent confidence 9/10

Built the support-graph wire-word scheduler with head-pointer feasibility, disjoint-support layer selection, prediction sweeps, and a grouped-MLP benchmark. All 17/17 quantitative toy checks matched prediction: independent chains had depth L and parallelism m, critical-path cases had depth max(critical, side), and shared-support precedence was preserved exactly. On the CUDA grouped MLP, the scheduled implementation reduced the launch proxy from 48 to 12 and measured 3.28x speedup at batch 1 and 3.58x at batch 32, with maximum absolute output error at or below 3.7e-9.

Agent confidence
9/10
Baseline
Grouped MLP sequential execution: 48 launch-proxy operations; 8.875 ms at batch 1 and 8.429 ms at batch 32.
Idea
Scheduled/fused execution: 12 launch-proxy operations; 2.709 ms at batch 1 and 2.355 ms at batch 32; speedups 3.276x and 3.579x; maximum absolute errors 0.0 and 3.7e-9.
Toy checks
17/17 prediction checks passed.

Limitations: The benchmark uses a small synthetic grouped MLP and compares a Python per-group baseline with a batched einsum implementation; launch counts are proxies rather than traced kernel-launch counts. No real traced Transformer, compiler integration, peak activation-memory measurement, training experiment, or multi-run statistical confidence interval was tested.

How to run: python3 scheduler_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.08841)

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

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

Operation-layer reduction was measured, but hardware kernel traces, latency, peak memory, compiler fusion, and a native transformer attention graph were not measured.

How to run: python3 stage2_scheduler_bench.py

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

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 10/10

The scheduler was evaluated on the registered sequence track with 8 paired seeds and a tuned baseline sweep. Its trained-model mechanism prediction was confirmed: 12 independent operator executions became 3 layers with parallelism 4 and zero alternate-path output error. The standard test MSE was unchanged, so there was no significant win.

Baseline
Best lr=0.01; 8-seed test MSE mean 0.31515853852033615, std 0.03953086118964313.
Comparison
delta_mean=3.725290298461914e-09, p_value=1.0, idea_wins=1/8.
Idea
Scheduled grouped execution at lr=0.01; 8-seed test MSE mean 0.31515854224562645, std 0.03953085904549802.

Benchmark result

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

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

Operation-layer reduction was measured, but hardware kernel traces, latency, peak memory, compiler fusion, and a native transformer attention graph were not measured.

How to run: python3 stage2_scheduler_bench.py

Artifacts

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