PaperlayerView exact revision on arXiv

Source-linked AI summary

Gated QKAN-FWP: Scalable Quantum-inspired Sequence Learning

Kuo-Chung Peng, Samuel Yen-Chi Chen, Jiun-Cheng Jiang, Chen-Yu Liu, En-Jui Kuo, Yun-Yuan Wang, Prayag Tiwari, Andrea Ceschini, Chi-Sheng Chen, Yu-Chao Hsu, Chun-Hua Lin, Tai-Yue Li, Antonello Rosato, Massimo Panella, Simon See, Saif Al-Kuwari, Kuan-Cheng Chen, Nan-Yow Chen, Hsi-Sheng Goan

arXiv:2605.06734v2cs.LGcs.AIquant-ph

TL;DR

Long-range sequence modeling remains difficult for scalable, trainable quantum architectures because existing quantum fast-weight programmers depend on costly multi-qubit circuits. Gated QKAN-FWP uses single-qubit QKAN activations and scalar-gated updates, outperforming larger recurrent baselines in solar forecasting while matching noiseless-simulator accuracy on IonQ and IBM processors within 0.1% relative MSE.

  • Problem

    Existing quantum fast-weight programmers rely on multi-qubit circuits, limiting practical scalability and increasing simulation and execution difficulty on NISQ hardware.

  • Method

    Gated QKAN-FWP integrates single-qubit DARUAN activations with a scalar-gated fast-weight update mechanism for sequence modeling.

  • Results

    12.5k-parameter gated QKAN-FWP outperformed recurrent baselines spanning 11.5k–167k parameters in solar forecasting and recovered simulator accuracy within 10^-3 relative MSE at 1024 shots on two QPUs.

  • Takeaways & Limitations

    The framework demonstrates parameter-efficient long-horizon forecasting and NISQ-compatible execution across time-series prediction and MiniGrid reinforcement learning.

  • Takeaways & Limitations

    The framework’s scalability for ultra-large input and output dimensions remains an open challenge requiring structural grouping and further analysis.

Abstract

from arXiv · show

Fast Weight Programmers (FWPs) encode temporal dependencies through dynamically updated parameters rather than recurrent hidden states. Quantum FWPs (QFWPs) extend this idea with variational quantum circuits (VQCs), but existing implementations rely on multi-qubit architectures that are difficult to scale on noisy intermediate-scale quantum (NISQ) devices and expensive to simulate classically. We propose gated QKAN-FWP, a fast-weight framework that integrates FWP with Quantum-inspired Kolmogorov-Arnold Network (QKAN) using single-qubit data re-uploading circuits as learnable nonlinear activation, known as DatA Re-Uploading ActivatioN (DARUAN). We further introduce a scalar-gated fast-weight update rule that stabilizes parameter evolution, supported by a theoretical analysis of its adaptive memory kernel, geometric boundedness, and parallelizable gradient paths. We evaluate the framework across time-series benchmarks, MiniGrid reinforcement learning, and highlight real-world solar cycle forecasting as our main practical result. In the long-horizon setting with 528-month input window and 132-month forecast horizon, our 12.5k-parameter model achieves lower scaled Mean Square Error (MSE), peak amplitude error, and peak timing error than a suite of classical recurrent baselines with up to 13x more parameters, including Long Short-Term Memory (LSTM) networks (25.9k-89.1k parameters), WaveNet-LSTM (167k), Vanilla recurrent neural network (11.5k), and a Modified Echo State Network (132k). To validate NISQ compatibility, we further deploy the trained fast programmer on IonQ and IBM Quantum processors, recovering forecasting accuracy within 0.1% relative MSE of the noiseless simulator at 1024 shots. These results position gated QKAN-FWP as a scalable, parameter-efficient, and NISQ-compatible approach to quantum-inspired sequence modeling.

1 Introduction

Gated QKAN-FWP addresses long-range sequence-learning challenges by combining fast-weight programming with single-qubit DARUAN activations and a scalar-gated update rule. The framework targets scalable, hardware-friendly modeling, demonstrating strong solar-forecasting performance and NISQ compatibility.

  • Design motivation: Single-qubit data re-uploading circuits provide expressive, hardware-friendly, and simulation-efficient learnable nonlinear activations.This design responds to the practical scalability, execution, simulation, and training limitations of multi-qubit quantum neural networks.
  • Framework: Gated QKAN-FWP integrates Quantum-inspired Kolmogorov–Arnold Network modules with fast-weight programming for efficient sequence modeling.Its DARUAN activations use single-qubit data re-uploading circuits, avoiding multi-qubit entanglement bottlenecks.
  • Mechanism: The scalar-gated fast-weight mechanism adaptively balances memory retention and new updates while supporting adaptive memory kernels, geometric bounds, and parallelizable unrolled recursion.The recursion yields shallower gradient paths than general recurrent neural networks.
  • Empirical evaluation: 12.5k parameters: the model outperforms classical recurrent baselines spanning 11.5k to 167k parameters on real-world multi-step solar cycle forecasting.The baselines can reach up to 13× the model’s size; evaluation also covers time-series benchmarks and MiniGrid reinforcement learning.
  • NISQ validation: 10−3 relative Mean Square Error (MSE): forecasting performance recovered within this margin of the noiseless simulator on two quantum processing units.This validates compatibility with noisy intermediate-scale quantum hardware.

2 Related Work

Related work spans quantum sequence modeling and reinforcement learning, fast-weight programming with quantum extensions, and KAN/QKAN architectures. These lines of research motivate combining dynamical parameter-based memory with quantum circuits and learnable nonlinear functions.

  • Quantum sequence modeling and reinforcement learning: QRNN and QLSTM variants adapt quantum neural architectures to temporally dependent sequence tasks, while quantum reinforcement learning has evolved from fully quantum environments toward VQCs in classical settings.The passage identifies multiple QRNN and QLSTM variants and contrasts early fully quantum QRL formulations with more recent VQC-based approaches.
  • Fast-weight programming and quantum extensions: Fast Weight Programmers replace recurrent hidden-state evolution with dynamical parameter evolution, with a slow network updating a fast network to enable memory-like behavior without explicit recurrence.Classical extensions combine FWPs with RNNs and establish analogies to linear Transformers.
  • Fast-weight programming and quantum extensions: Quantum Fast Weight Programmers use parameterized quantum circuits as fast programmers, with a classical slow network generating circuit parameters on the fly.This design eliminates explicit quantum gradient computation inside the fast programmer.
  • KAN and QKAN architectures: KANs replace fixed MLP activations with learnable univariate functions for interpretable, parameter-efficient nonlinear modeling, and this approach has been adapted to temporal sequence tasks.QKAN implements KAN edge functions with DARUAN.

3 Preliminaries

The preliminaries define QKAN’s single-qubit DARUAN activations, the HQKAN encoder–processor–decoder architecture, and fast-weight programming through evolving parameter trajectories. They also position QFWP as a VQC-based fast programmer whose quantum parameters are updated over time.

  • QKAN: QKAN replaces classical KAN spline edge functions with quantum-inspired univariate DARUAN functions implemented by single-qubit data re-uploading circuits.Repeated data re-uploading induces a rich Fourier spectrum, enabling highly nonlinear mappings with relatively few trainable parameters.
  • HQKAN: HQKAN uses a classical encoder, latent QKAN processor, and decoder, functioning as a compact nonlinear programmer network within the fast-weight framework.As a slow programmer, HQKAN generates fast-parameter updates; as a fast programmer, its DARUAN parameters are dynamically updated.
  • FWP: FWPs encode temporal dependencies through the trajectory of dynamically evolving fast parameters rather than hidden-state recurrence.The fast network uses time-dependent parameters W_t, while a slow programmer generates their updates from the current input.
  • QFWP: QFWP uses a variational quantum circuit as its fast programmer, with encoded layer and qubit vectors forming updates to time-dependent quantum parameters.The quantum parameters Θ_t are updated by Θ_t+1 = Θ_t + ΔΘ_t, and the output is the fast VQC’s expectation value.

4 Methods

The method stabilizes fast-parameter evolution with a scalar gate that interpolates between stored parameters and new updates. It evaluates classical and HQKAN-based gated fast programmers, including GQKAN-FWP and GQKAN-QKANFWP.

  • Gated fast-parameter updates: A scalar sigmoid gate g_t ∈[0, 1] interpolates between previously stored fast parameters and newly generated updates at each time step.Unlike element-wise matrix gating, the scalar gate provides uniform parameter scaling and supports parameter efficiency and scalability.
  • Gated fast-parameter updates: When g_t →1, the model retains stored fast parameters; when g_t →0, it relies entirely on the newly generated update.The framework analyzes these update dynamics theoretically in Section 5.
  • Ablation variants: Ungated classical fast programmers update parameters using W_t+1 = W_t + L_t ⊗D_t and b_t+1 = b_t + B_t.Their prediction is produced from the updated fast weight and bias.
  • Ablation variants: Gated variants, including G-FWP and GQKAN-FWP, instead evolve fast parameters through the gated update mechanism.For HQKAN-based programmers, the slow programmer generates both the parameter update Δϕ_t and scalar gate g_t.
  • Architectures: GQKAN-FWP uses HQKAN as a slow programmer for a classical linear fast programmer, whereas GQKAN-QKANFWP uses HQKAN for both programmers.In the latter architecture, the slow programmer generates DARUAN parameters for the fast module under the same gated mechanism.

5 Theoretical Analysis

The gated fast-weight recursion is theoretically characterized as adaptive convex aggregation with input-dependent memory, geometric boundedness, and parallelizable parameter evolution. These properties provide forgetting, norm control, shallow gradient paths, and a rationale for improved stability over ungated updates.

  • Implication: Overall implication: The gate combines adaptive memory, bounded fast-parameter geometry, and parallel hidden-state-free evolution, helping explain improved stability relative to ungated variants.The ungated recursion accumulates all past updates additively without a forgetting mechanism.
  • Unrolled form and adaptive memory kernel: Adaptive memory kernel: Gating weights historical fast-state proposals, enabling long-memory behavior when gates stay near 1 and rapid forgetting when gates are small.With constant gate g, the kernel becomes exponential.
  • Geometric boundedness: Geometric boundedness: The gated update keeps fast parameters inside the convex hull of initialization and historical proposals, unlike ungated additive accumulation.Ungated dynamics can grow linearly with sequence length in the worst case, whereas gating provides a norm bound controlled by historical proposals.
  • Parallelizable parameter evolution and shallow gradient path: Parallel parameter generation: Because each proposed update and gate depends only on its input, all {(∆Wk, gk)}T_k=1 can be computed in one parallel pass.This preserves the hidden-state-free structure of fast-weight programming.
  • Parallelizable parameter evolution and shallow gradient path: O(log T) scan depth: Associative composition resolves the gated recursion with p = Θ(T) processors, versus Ω(T) sequential depth for general nonlinear recurrent hidden-state evolution.Gradients propagate through scalar gate products and independent slow-programmer forward passes rather than T dense hidden-state Jacobians as in QKAN-LSTM.

6 Experimental Results

Experiments across time-series prediction, solar-cycle forecasting, and MiniGrid reinforcement learning show that gated QKAN-FWP variants improve accuracy, stability, and long-range performance. GQKAN-QKANFWP is especially strong, achieving broad benchmark robustness and leading solar-cycle metrics with far fewer parameters than classical baselines.

  • Evaluation protocol: Five random seeds and exact-gradient classical quantum simulations provide the evaluation protocol across time-series, forecasting, and reinforcement-learning experiments.Quantum baselines use classical simulators without hardware noise or finite measurement shots.
  • Time-series benchmarks: GQKAN-QKANFWP achieves the best result on three of six fixed-window datasets, while GQKAN-FWP and G-QKANFWP rank among the top two across multiple tasks.The four strongest variants advance to variable-window evaluation.
  • Time-series benchmarks: 10 of 24 variable-window settings have the lowest prediction error for GQKAN-QKANFWP, which shows the greatest robustness as N varies.G-QKANFWP dominates NARMA5 and NARMA10 at longer windows, while GQKAN-FWP leads on DQC and JC.
  • Time-series benchmarks: 2 × 10^-6 MSE at N=16 for QFWP worsens to 1.3 × 10^-4 at N ∈{32, 64}, a roughly 60× degradation.The reported degradation motivates the gated variants’ stronger accuracy-stability balance across window sizes.
  • Solar Cycle forecasting: 12.5k parameters enable GQKAN-QKANFWP to achieve the lowest scaled MSE, PAE, and PTE in 528-month-to-132-month solar-cycle forecasting.This is roughly 7–13× fewer parameters than LSTM-L, MESN, and WaveNet-LSTM, with the lowest scaled-MSE variance of ±0.0016.

7 Conclusion

The conclusion presents gated QKAN-FWP as a scalable, parameter-efficient, and NISQ-compatible sequence-learning framework. Its scalar-gated updates, strong forecasting results, quantum-processor validation, and reduced-dimensional design address scalability and execution bottlenecks while retaining broad task performance.

  • Contributions: Gated QKAN-FWP mitigates NISQ scalability and execution bottlenecks by relying exclusively on HQKAN and avoiding multi-qubit entanglement costs.HQKAN modules were empirically shown capable of scaling to LLMs.
  • Contributions: The scalar-gated fast-weight update stabilizes parameter evolution through adaptive memory kernels, geometric boundedness, and a parallel-scan-compatible recursion.
  • Empirical results: 12.5k-parameter GQKAN-QKANFWP achieved lower scaled MSE, PAE, and PTE than classical recurrent baselines spanning 11.5k to 167k parameters on real-world solar cycle forecasting.HQKAN-based gated variants also showed the greatest robustness over extended input windows in time-series prediction.
  • Empirical results: ∼10−3 relative MSE of the simulator was recovered by Forte-1 and IBM’s ibm_aachen at 1024 shots, confirming NISQ compatibility of the single-qubit design.
  • Empirical results: 58% parameter reduction relative to prior baselines accompanied competitive performance in the MiniGrid RL task.
  • Scalability and limitations: Autoregressive processing keeps HQKAN input dimension independent of sequence length, while reduced-dimensional latent-space computation compresses overhead for large input/output tasks.Structural grouping can further manage overhead for ultra-large input/output dimensions.

A Parallel Evaluation of the Gated Fast-Weight Recursion · A.1 Affine Reformulation and Associativity · A.2 Trajectory as a Prefix Product

The gated fast-weight recursion can be reformulated as an associative affine scan over scalar–matrix pairs, making its parameter trajectory a parallelizable prefix product. This structure yields logarithmic parallel depth while preserving sequence order through non-commutative composition.

  • A Parallel Evaluation of the Gated Fast-Weight Recursion: The full trajectory is computable in O(log T) depth on an unbounded-processor PRAM and O(T/p + log p) time on p processors.This contrasts with the Ω(T) sequential depth required for general nonlinear recurrences.
  • A.1 Affine Reformulation and Associativity: The gated recursion W_t+1 = g_t W_t + (1 − g_t) ΔW_t becomes an affine recurrence with scalar multiplier a_t and matrix offset b_t.The gate satisfies g_t ∈ [0, 1], with a_t := g_t and b_t := (1 − g_t) ΔW_t.
  • A Parallel Evaluation of the Gated Fast-Weight Recursion: Because gates and proposals depend on the current input alone rather than previous fast parameters, all affine pairs can be computed in a single parallel pass over time.This input-only dependence is the structural source of the recursion’s parallel evaluation.
  • A.1 Affine Reformulation and Associativity: Scalar gating keeps the scan payload compact, avoiding the O(m^2) payload and dense-matrix gradient products induced by matrix-valued multipliers.The scalar gate also avoids reintroducing the conditioning issues associated with multiplying T dense matrices.
  • A.1 Affine Reformulation and Associativity: The affine-pair composition operator is associative for arbitrary scalar multipliers and matrix offsets, without requiring constant, smooth, or input-independent gates.The pair (1, 0_m×n) serves as a two-sided identity, while composition is generally non-commutative.
  • A.2 Trajectory as a Prefix Product: Each recursion step is one affine-pair composition, so the complete fast-parameter trajectory is represented by running prefix products.The second component of the t-th prefix product equals the fast-parameter state at time t+1.
  • A.2 Trajectory as a Prefix Product: For T = 3, the prefix-product expansion recovers W4 as gated contributions from W1 and ΔW1, ΔW2, and ΔW3.The resulting expression matches the recursively unrolled form term by term.
  • A.2 Trajectory as a Prefix Product: Associativity permits balanced tree reassociation, allowing independent inner compositions to execute concurrently and forming the basis of the parallel scan.The tree-shaped evaluation preserves the same prefix product while exposing parallel work.

A.3 Parallel Evaluation via Associative Scan

Associative scan evaluates the gated fast-weight parameter trajectory in O(log T) depth with O(T) operator work, while preserving the sequential O(Tmn) scalar cost. On p processors, its three-phase implementation provides linear speedup when p ≪ T and avoids temporal serialization across the parameter sequence.

  • Unbounded-processor scan: O(log T) depth and O(T) work characterize the balanced-tree up-sweep/down-sweep scan, matching sequential evaluation up to a constant factor.Each tree level executes independently in parallel, while the total number of associative operations remains linear in T.
  • Work complexity: O(Tmn) scalar operations result from the scan for W ∈ R^m×n, identical up to constants to sequential scalar-matrix-add recursion.Each operator uses one scalar multiplication, one scalar-times-matrix scaling, and one matrix addition.
  • Bounded-processor scan: Three phases—local reduction, tree-based block scan, and local propagation—yield linear speedup in p when p ≪ T, while p = Θ(T) recovers O(log T) depth.The block-based implementation assigns contiguous input blocks, scans their reductions, and propagates prefixes within each block.
  • Application to fast weights: Up to 9× practical speedups have been demonstrated for related feature-space linear recurrences, and the same primitive applies once to the gated fast-weight parameter sequence.Unlike nonlinear recurrent architectures, the parameter-space scan produces the entire trajectory {W_t}^T_t=1 without serializing over t in forward and backward passes.

A.4 Sequential Depth Lower Bound for Nonlinear Recurrences … B.3 Backpropagation through the fast parameters

The gated fast-weight recursion avoids the linear sequential depth of general nonlinear recurrences through an associative affine scan. Its scalar-gated structure also simplifies temporal gradient propagation, replacing dense recurrent Jacobians with scalar products and independent per-step paths.

  • A.4 Sequential Depth Lower Bound for Nonlinear Recurrences: General nonlinear recurrences require Ω(T) sequential applications of f to compute h_T from h_0, preventing associative-scan acceleration.This lower bound holds regardless of available parallelism.
  • A.4 Sequential Depth Lower Bound for Nonlinear Recurrences: The gated fast-weight framework decouples parameter evolution from hidden-state loops, unlike QKAN-LSTM, which inherits LSTM sequential depth and BPTT through T dense hidden-state Jacobians.Each parameter update is computed from its corresponding input rather than traversing a recurrent hidden-state chain.
  • A.4 Sequential Depth Lower Bound for Nonlinear Recurrences: The affine gated recursion supports an associative composition law, enabling parameter trajectories to be evaluated by a prefix scan in logarithmic depth.The parallel structure follows directly from scalar gating.
  • B Gradient Composition in the Gated Fast-Weight Recursion: The same affine structure makes sensitivity to an earlier proposal a scalar multiplier, so temporal dependencies propagate through products of scalar gates rather than dense Jacobian chains.This yields shallower gradient propagation along the time axis.
  • B.1 Unrolled form revisited: The unrolled fast-weight state lies in the convex hull of {W_1, ∆W_1, . . . , ∆W_t}, with memory coefficients β_k,t ∈[0, 1].This recovers the recursion’s geometric boundedness property.
  • B.2 Sensitivity to a single proposal: The Jacobian of W_t+1 with respect to ∆W_k is a scalar multiple of the mn × mn identity, with β_k,t propagated independently across parameter coordinates.The dense Jacobian therefore collapses to one scalar multiplier.
  • B.3 Backpropagation through the fast parameters: The gradient from time t + 1 to step k is the upstream gradient rescaled by β_k,t, without matrix multiplication along the temporal direction.For slow-programmer weights, temporal depth is controlled by β_k,t, while each proposal gradient traverses only one constant-depth forward pass.

B.4 Bounded, non-explosive gradient magnitudes

The gated update bounds temporal gradient magnitudes by construction, preventing exploding gradients without clipping or spectral regularization. However, consistently small gates can cause geometric decay and vanishing gradients, creating an adaptive-memory trade-off.

  • Gradient boundedness: The scalar coefficients β_k,t are products of factors in [0, 1].Their multiplicative structure underlies the gradient bound.
  • Gradient boundedness: 1: The temporal Jacobian norm is bounded above by 1 for every (k, t).This establishes non-explosive temporal gradient magnitudes.
  • Gradient boundedness: Repeated temporal composition can only contract gradients, ruling out exploding gradients without gradient clipping or spectral regularization.The guarantee follows directly from the bounded multiplicative factors.
  • Adaptive-memory trade-off: Small gates can make gradients to early ΔW_k vanish geometrically, while gates near 1 retain long-range flow and gates near 0 implement aggressive forgetting.This is the standard adaptive-memory trade-off.
  • Adaptive-memory trade-off: The slow programmer produces gates from x_s alone, allowing gate values to be learned per input rather than fixed.This lets the model potentially retain long-range dependencies when warranted by the data.

B.5 Comparison with dense recurrent Jacobians

The gated fast-weight framework replaces temporal products of dense recurrent Jacobians with scalar coefficients in [0, 1]. This provides bounded gradient magnitudes and enables temporal gradient paths to be evaluated through parallel reductions.

  • Gradient composition: Dense recurrent Jacobian products can cause exploding or vanishing gradients because their spectral norm grows or shrinks geometrically with t − k.The sensitivity depends on every entry of every intermediate Jacobian.
  • Computational comparison: Backpropagation through time for dense recurrences requires storing all T activations and sequentially multiplying T dense d×d matrices, costing O(Td3) work and Ω(T) depth.These requirements arise from recomputing or querying intermediate Jacobians during the backward pass.
  • Gradient composition: Scalar coefficients in [0, 1] replace products of dense Jacobians in the gated fast-weight recursion.The framework substitutes the dense Jacobian product with the scalar product β_k,t.
  • Computational comparison: The gated recursion yields bounded, non-explosive gradient magnitudes by construction and reduces effective temporal gradient depth through parallel reductions.The summary identifies these as advantages over general nonlinear recurrences.

C Convergence Analysis on Time-Series Benchmarks

At window size N = 64, GQKAN-QKANFWP converges earlier and more stably than QFWP across smooth, nonlinear, and quantum-dynamics benchmarks. Its advantage is especially clear on long-memory and high-frequency tasks, where QFWP retains wider uncertainty and poorer extrapolation.

  • Convergence overview: By epoch 15, GQKAN-QKANFWP reaches near-perfect ground-truth overlap on smooth-dynamics and quantum-dynamics tasks, earlier than QFWP.The comparison extends convergence analysis to 100 epochs at the demanding window size N = 64.
  • Convergence overview: GQKAN-QKANFWP maintains a tight ±1σ envelope from early epochs, while QFWP shows wider variability that often expands beyond the train/test boundary.This pattern indicates greater seed-to-seed stability and stronger out-of-sample behavior for GQKAN-QKANFWP at long input windows.
  • Smooth dynamics: From epoch 15 onward, GQKAN-QKANFWP visually matches the Damped SHM ground truth with a ±1σ band narrow enough to remain within the plotted line.Damped SHM tests amplitude tracking, retention of a slow envelope, and sensitivity to nonlinearity.
  • Smooth dynamics: At epoch 15, GQKAN-QKANFWP tracks both the period and slowly decaying amplitude envelope of the Bessel function J2(x) with a tight variance band.The Bessel envelope decays as a power law (∼x−1/2) and its local period drifts mildly with x.
  • Nonlinear autoregressive tasks: Around epoch 30, GQKAN-QKANFWP begins recovering NARMA5 peak structure and sharpens its peaks through epoch 100, whereas QFWP remains essentially flat.At epoch 15, both models predict a near-constant trajectory, reflecting the difficulty of learning the nonlinear dependence from a 64-step window.
  • Nonlinear autoregressive tasks: By epoch 50, GQKAN-QKANFWP resolves larger NARMA10 peaks and by epoch 100 tracks major and minor variations with a tight variance envelope, while QFWP captures only a smoothed trend.NARMA10 doubles the autoregressive order to n0 = 10, amplifying the difficulty of capturing the autoregressive structure.
  • Quantum dynamics: From epoch 15 onward, GQKAN-QKANFWP reproduces Delayed Quantum Control pulse shapes and decaying envelopes with a variance band within the mean curve.QFWP tracks the dominant pulse structure in training but visibly degrades past the train/test split.
  • Quantum dynamics: At epoch 15, GQKAN-QKANFWP overlays the Jaynes–Cummings ground truth, while QFWP underestimates amplitude by roughly half and accumulates extrapolation errors.QFWP still fails to match the ground-truth envelope at epoch 100, indicating a representational rather than optimization gap.
Loading 2605.06734v2…