✓ Mechanism works 2026

Conjugacy-Regularized Latent Dynamics

Implementation & benchmark of arXiv:2607.04493 — Beyond DSA: Conjugacy-based Comparison of Dynamical Systems

Usefulness7/10
Difficulty5/10
Novelty6/10

Source paper: Beyond DSA: Conjugacy-based Comparison of Dynamical Systems arXiv:2607.04493 ⓘ · analyzed Aug 29, 2026

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

Idea description

Replace orthogonal Procrustes alignment between two latent dynamical systems with a learned bijection h that makes their transitions commute: h(f(z)) approximately equals g(h(z)). Parameterize h as an invertible affine map or coupling flow, allowing the correspondence to be non-orthogonal while retaining an exact inverse. The same constraint can be applied over multiple rollout steps, encouraging two models to represent the same computation even when their latent coordinates differ substantially.

Formulas

$$h\circ f=g\circ h$$
$$(\mathcal{K}_{f}u)(x)=u(f(x)),\qquad (\mathcal{K}_{g}v)(y)=v(g(y))$$
$$\mathcal{K}_{f}(v\circ h)=(\mathcal{K}_{g}v)\circ h$$
$$\mathcal{L}_{\mathrm{conj}}=\frac{1}{BT}\sum_{b=1}^{B}\sum_{t=0}^{T-1}\left\|H_\psi(F_\theta(z_t^{(b)}))-G_\phi(H_\psi(z_t^{(b)}))\right\|_2^2+\lambda_{\mathrm{inv}}\left\|H_\psi^{-1}(H_\psi(z_t^{(b)}))-z_t^{(b)}\right\|_2^2+\lambda_{\mathrm{roll}}\sum_{k=2}^{K}\left\|H_\psi(F_\theta^{k}(z_t^{(b)}))-G_\phi^{k}(H_\psi(z_t^{(b)}))\right\|_2^2$$

Mathematical statement

The paper defines discrete-time systems f:X o X and g:Y o Y and calls them topologically conjugate when there is a bijection h:X o Y satisfying h\circ f=g\circ h. Here x\in X and y\in Y are states, f and g are one-step transition maps, and h is the state-space relabeling. The paper also defines the Koopman operator on scalar observables u and v by (\mathcal{K}_f u)(x)=u(f(x)) and (\mathcal{K}_g v)(y)=v(g(y)). Conjugacy implies the observable relation \mathcal{K}_f(v\circ h)=(\mathcal{K}_g v)\circ h: pulling an observable on Y back through h makes the two Koopman dynamics agree. In the neural adaptation, z_t\in\mathbb{R}^d is the latent state of model A, w_t\in\mathbb{R}^d is the latent state of model B, F_ heta and G_\phi are learned transitions, and H_\psi is an invertible approximation to h. The training residual is r_t=H_\psi(F_ heta(z_t))-G_\phi(H_\psi(z_t)); minimizing \|r_t\|^2 enforces the finite-data version of h\circ f=g\circ h. Add an inverse residual using H_\psi^{-1} to prevent collapse and a rollout residual for k>1. No orthogonality constraint is required; if H_\psi is affine, its matrix A may be any nonsingular matrix rather than an orthogonal matrix.

Implementation notes

(1) Integration point: apply this to the latent transition of two RNN, SSM, or world-model instances that should encode the same process. Let encoder A produce z_t from observations and encoder B produce w_t; use F_theta and G_phi for their latent one-step transitions. Insert H_psi between the two latent spaces only inside the conjugacy loss, not in the observation decoder. Start with H_psi(z)=Az+b, parameterize A as a full nonsingular matrix initialized near identity, or use a RealNVP coupling flow for a more expressive bijection.

(2) Pseudocode:

for batch of trajectories x[0:T]:
    z = encoder_A(x); w = encoder_B(x)
    loss = task_loss_A + task_loss_B
    for t in 0..T-1:
        z_next = F_theta(z[t])
        loss += lambda1 * mse(H_psi(z_next), G_phi(H_psi(z[t])))
    for t in sampled_times and k in 2..K:
        loss += lambda_roll * mse(H_psi(iterate(F_theta,z[t],k)), iterate(G_phi,H_psi(z[t]),k))
    loss += lambda_inv * mse(H_inv(H(z)), z)
    update theta, phi, psi with AdamW

The one-step residual is the adapted form of h\circ f=g\circ h, and the multi-step term tests trajectory consistency rather than only local consistency.

(3) Computed from the mathematics: the commuting-map residual, inverse consistency, and optional observable residual. Estimated empirically: latent states, transition maps, rollout horizon K, and loss weights. Track the singular values and condition number of A, or the Jacobian determinants of the flow; reject runs where H becomes numerically singular. Compare against orthogonal Procrustes alignment and an unconstrained MLP alignment.

(4) First experiment: train two 2-layer GRU predictors on Lorenz-63 or damped-pendulum trajectories, with model B observations generated by a fixed shear and scaling of model A's state. Use 16- or 32-dimensional latents and evaluate one- to 50-step rollout error after mapping B into A coordinates. The conjugacy model should achieve low transition-commutation error under the deliberately non-orthogonal transform, while orthogonal alignment should show a residual floor. A second test should use independently initialized GRUs on identical sequences and measure whether conjugacy regularization improves long-horizon prediction at equal parameter count.

Verification

Mechanism works

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not tested

Stage 2 · Practical benchmark result: Not run

Methodology: Toy-system gate first; the benchmark stage runs only after a pass. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built an invertible affine conjugacy module using a matrix-exponential parameterization with determinant-one constraint, plus one-step and multi-step commuting residuals. The exact similarity and Koopman identities passed at approximately 1e-16 relative error. In the synthetic non-orthogonal system, conjugacy reduced one-step residual from 0.465 to 0.085 and rollout residuals at k=2,5,10 from 0.695,0.821,0.800 to 0.135,0.263,0.351; the longer run produced essentially the same result, so the residual improvement is real in this test.

Agent confidence
8/10
Baseline
Orthogonal Procrustes: commutation 0.46494; rollout k=1,2,5,10 = 0.46494, 0.69468, 0.82126, 0.80041; state mapping error 0.57726.
Idea
Invertible affine conjugacy: commutation 0.08489; rollout k=1,2,5,10 = 0.08489, 0.13539, 0.26253, 0.35070; matrix condition 9.69 and determinant 1.0.

Limitations: Only a small noiseless linear synthetic system was tested, not GRUs, nonlinear Lorenz or pendulum trajectories, learned encoders/decoders, observation prediction loss, RealNVP flows, multiple random seeds, or equal-FLOP predictive accuracy. The learned affine map did not recover the particular ground-truth coordinate transform closely, despite reducing the commuting residual.

How to run: python3 run_experiment.py

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

Artifacts

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