△ Mechanism confirmed, baseline not beaten 2026

Identity-Paired Progressive Depth

Implementation & benchmark of arXiv:2607.16800 — Identity-Paired Progressive Depth Training: When Trainability Persists Beyond Expressibility

Usefulness7/10
Difficulty5/10
Novelty5/10

Source paper: Identity-Paired Progressive Depth Training: When Trainability Persists Beyond Expressibility arXiv:2607.16800 ⓘ · analyzed Aug 30, 2026

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

Idea description

Grow a neural network by appending a trainable block together with an analytically initialized inverse block, so the newly added depth is exactly the identity at insertion time. After insertion, untie and optimize the two blocks independently; this preserves the current function while providing additional trainable degrees of freedom. For architectures with one expensive mixing operation followed by cheap channelwise blocks, the same construction can increase depth without repeatedly paying for global mixing.

Formulas

$$\left(\bigotimes_{q=1}^{n}\mathbf{A}_{q}\right)\left(\bigotimes_{q=1}^{n}\mathbf{B}_{q}\right)=\bigotimes_{q=1}^{n}(\mathbf{A}_{q}\mathbf{B}_{q})$$
$$U^{-1}U=I,\qquad F_{\mathrm{new}}(x)=B_{\theta_0}^{-1}(B_{\theta_0}(F_{\mathrm{old}}(x)))=F_{\mathrm{old}}(x)$$
$$C_{f,g}(x_a,x_b)=\left(x_a+f(x_b),\;x_b+g\bigl(x_a+f(x_b)\bigr)\right)$$ $$C_{f,g}^{-1}(y_a,y_b)=\left(y_a-f\bigl(y_b-g(y_a)\bigr),\;y_b-g(y_a)\right)$$
$$\mathcal L_{t+1}\leq\mathcal L_t\quad\text{accept the depth expansion; otherwise restore depth }t$$

Mathematical statement

The paper uses the mixed-product identity for tensor-product operators, $\left(\bigotimes_{q=1}^{n}\mathbf{A}_{q}\right)\left(\bigotimes_{q=1}^{n}\mathbf{B}_{q}\right)=\bigotimes_{q=1}^{n}(\mathbf{A}_{q}\mathbf{B}_{q})$, where $\mathbf A_q$ and $\mathbf B_q$ are square operators on qubit $q$. Its identity-paired construction relies on the cancellation law $U^{-1}U=I$: a forward rotation/entangler block followed by its reverse has no functional effect at initialization. We transfer this to an invertible neural block $B_\theta$ with an exactly computable inverse $B_\theta^{-1}$, and insert $B_{\theta_0}^{-1}\circ B_{\theta_0}$, where $\theta_0$ is the copied parameter tensor and $I$ is the identity map. The two copies are then untied, so the inserted pair remains identity only at insertion time, not as a permanent architectural constraint. For a classical residual implementation, exact inversion is guaranteed by additive coupling: for $x=(x_a,x_b)$, $C_{f,g}(x_a,x_b)=(x_a+f(x_b),x_b+g(x_a+f(x_b)))$ and $C_{f,g}^{-1}(y_a,y_b)=(y_a-f(y_b-g(y_a)),y_b-g(y_a))$. The continuation acceptance rule is $\mathcal L_{t+1}\leq\mathcal L_t$, where $\mathcal L_t$ is the monitored training or validation loss after expanding to depth $t$.

Implementation notes

Integrate this at the depth-growth mechanism of a residual MLP, encoder-only Transformer, or sequence model. Prefer additive-coupling blocks because their inverse is explicit and does not require a matrix inverse. Split each hidden vector into two equal channel groups $(x_a,x_b)$ and implement one coupling block $C_{f,g}$ using small MLPs or depthwise linear layers for $f$ and $g$. During progressive training, first train a shallow model. To expand it, copy an existing coupling block with parameters $\theta_0$, append $C_{\theta_0}$, and immediately append its inverse $C^{-1}_{\theta_0}$; the forward pass is unchanged up to floating-point error. At the next optimizer step, replace the copied parameters by two independent parameter sets $\theta_+$ and $\theta_-$, while retaining the inverse-form computation for the second block only at initialization. In a simpler residual variant, use an invertible linear or orthogonal block $B_W(x)=Wx$ and append $W^{-1}W$, estimating $W^{-1}$ exactly from a stored orthogonal parameterization. For a Transformer, apply the pair around an FFN or around one attention-mixing layer; test a low-cost version in which only the first block contains attention and later paired blocks contain channelwise FFNs. After every expansion, run a short fixed budget of minibatches, evaluate validation loss, and accept the expansion only if $\mathcal L_{t+1}\leq\mathcal L_t+\epsilon$; otherwise remove the pair or reduce its learning rate. What is exact from the mathematics is the identity cancellation and reversible inverse. What must be estimated empirically is whether the extra untied parameters improve optimization after cancellation. The first experiment should use a 6-layer versus progressively grown 12-layer Transformer on WikiText-2 or CIFAR-10, with standard same-width training as baseline. Measure loss immediately before and after insertion, loss after 1,000 updates, gradient norm spikes, wall-clock cost, and final validation accuracy. Success means no insertion loss spike, lower loss at equal optimizer steps, and at least comparable final accuracy despite starting from the shallow model.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

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 an additive-coupling identity-paired depth-growth module with an explicit inverse, plus reproducible math sweeps and a mini regression experiment. The mechanism manifested: inverse composition remained numerically identity, cancellation error increased with coupling scale, and untied output perturbation scaled linearly with step size. Insertion caused only a 7.0e-8 relative loss change, but the paired model did not beat continued shallow training after 300 updates in this tiny task.

Agent confidence
8/10
Baseline
Continued shallow model: final MSE 1.896e-14 after 300 post-expansion-equivalent updates.
Cancellation sweep
Relative reconstruction error increased from 6.05e-9 at scale 0.01 to 6.52e-8 at scale 1.0.
Idea
Identity-paired model: insertion relative loss change 7.018e-8; final MSE 5.052e-14 after 300 updates; best MSE 2.020e-14.
Random deep
Randomly initialized deeper model: final MSE 7.667e-5.
Untied scaling
Output perturbation log-log slope 0.9995 across step sizes 1e-5 to 1e-3, matching the predicted slope of 1.

Limitations: The experiment used a tiny synthetic regression problem rather than CIFAR-10, WikiText-2, or a Transformer. It tested one seed, one width, and one expansion, with no large-scale FLOP-normalized comparison or validation-based rollback sweep.

How to run: python3 identity_paired_experiment.py

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

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

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

Only the built-in sequence track, transformer_tiny model, one expansion pair, 8 epochs, 400 training samples, 200 test samples, and the three-point lr/weight-decay sweep were tested. No CIFAR, dynamics, larger transformers, multiple progressive expansion stages, FLOP-normalized timing, or rollback/acceptance schedule was evaluated.

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

Implemented Identity-Paired Progressive Depth as an additive diagonal coupling block followed by its analytically computed inverse, inserted into the matched built-in sequence transformer. Across 8 paired seeds, the idea had higher test MSE than the tuned baseline (0.5841716528 vs 0.5621015988), with paired delta +0.0220700540 and permutation p=0.5933, so there is no task-metric win. The trained-model mechanism signature was quantitatively confirmed: insertion output change was 1.729e-8 relative and the untied perturbation slope was approximately 1.0, but this did not improve learning.

Baseline
transformer_tiny on built-in sequence track; best lr=0.0015, weight_decay=0.0; full 8-seed MSE mean=0.562101598829031, std=0.08060035643973527.
Idea
Matched transformer with identity-paired diagonal additive coupling; shared lr grid [0.0015, 0.003, 0.006], best reported 8-seed MSE mean=0.5841716527938843, std=0.05076107251588834.
Mechanism signature
map[confirmed:true mean_insertion_relative_output_change:1.7291444720513027e-08 mean_trained_pair_residual:0.028601060970686376 trained_untied_loglog_slope:approximately 1.0]
Paired delta
idea - baseline = +0.022070053964853287 MSE; idea wins 3/8 pairs.
Permutation p value
0.5933

Benchmark result

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

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

Only the built-in sequence track, transformer_tiny model, one expansion pair, 8 epochs, 400 training samples, 200 test samples, and the three-point lr/weight-decay sweep were tested. No CIFAR, dynamics, larger transformers, multiple progressive expansion stages, FLOP-normalized timing, or rollback/acceptance schedule was evaluated.

How to run: python3 bench_identity_paired.py

Artifacts

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