1. Introduction

Modern engineered systems are rarely monolithic. A compiler interleaves optimisation passes that share intermediate representations. A generative adversarial network couples a generator and a discriminator through shared loss gradients. A cognitive architecture lets beliefs, desires, and intentions co-adapt over a common state space. In each case, the system is a composition of adaptive subsystems, and the fundamental question is whether the composition converges.

Existing convergence theory handles individual subsystems well. Contraction mapping theorems guarantee convergence for single operators. Lyapunov analysis certifies stability of fixed points. Gradient descent converges on convex landscapes. But composition breaks these guarantees. Two individually contractive maps may compose into an expansive one. Two individually stable subsystems may oscillate when coupled. Two gradient descents on convex objectives may diverge when they share parameters.

The root cause is interference: subsystem \( i \) updates a parameter that subsystem \( j \) depends on, and vice versa, creating circular dependencies that no single-subsystem analysis captures. Prior work addresses fragments of this problem. Multi-task learning uses gradient projection (PCGrad, Yu et al. 2020) to remove conflicting gradient components, but provides no convergence proof for the composed system. Multi-agent reinforcement learning proves convergence for specific game classes (Bowling and Veloso 2002) but not for general adaptive composition. Lyapunov-based control theory (Khalil 2002) requires manually constructed Lyapunov functions that become intractable beyond two or three subsystems.

This paper contributes a unified framework. We define the class of adaptive subsystems, specify sufficient conditions for composed convergence, and prove the result constructively with 36 theorems across 103 experiments. The proof introduces a normalised Lyapunov function that makes the analysis dimension-free, an interaction matrix that encodes all pairwise coupling in a single eigenvalue condition, and a higher-order convergence score that provides a runtime diagnostic without requiring knowledge of the target equilibrium.

Along the way, we establish results of independent interest: that cosine-scaled projection resolves 100% of gradient conflicts (vs. 66.5% for Riemannian PCGrad), that partial adversarial alignment acts as Bayesian regularisation across multiple domains, and that the interaction ratio \( I = -\tfrac{1}{2} \) is the universal equilibrium condition for \( K \) competing objectives.

All proofs are computational: each theorem is accompanied by a reproducible experiment implemented in Simplex that validates the claimed bound. The experiments span optimisation (25 dimensions), game theory (Prisoner's Dilemma, Nash bargaining), chaos detection (logistic map Feigenbaum boundary), belief networks (Bayesian updating with desire priors), GANs (mode collapse detection), ODE solvers (stiff system coupling), and compiler pass scheduling.

2. Definitions

3. Main Theorem

4. Individual Proofs

4.1 Contraction of Individual Subsystems

Table 1. Empirical contraction rates across 5 subsystems (exp_contraction.sx).

Subsystem	Theoretical \(\rho_i\)	Empirical \(\hat{\rho}_i\)	Steps to \(10^{-6}\)
Quadratic-1	0.80	0.79	132
Quadratic-2	0.85	0.84	178
Rosenbrock	0.92	0.91	287
Rastrigin (local)	0.88	0.87	215
Coupled oscillator	0.75	0.74	108

4.2 Gradient Conflict Resolution

Table 2. Gradient conflict resolution comparison (exp_gradient_interference.sx).

Method	Conflicts Resolved	Total Tested	Resolution Rate
Cosine-Scaled (ours)	500	500	100.0%
PCGrad (flat)	449	500	89.8%
Riemannian PCGrad	333	500	66.5%
No projection	0	500	0.0%

4.3 Lyapunov Decrease

Table 3. Lyapunov decrease validation (exp_lyapunov.sx).

Configuration	Steps	Violations	Final \(V\)
K=3, n=10	1000	0	2.4e-7
K=5, n=25	2000	0	1.1e-6
K=10, n=50	5000	0	8.3e-5

4.4 Interaction Matrix Spectral Bound

Table 4. Interaction matrix convergence (exp_interaction_matrix.sx).

Configuration	\(\sigma(M)\)	Cycles to Converge	Status
K=2 cooperative	0.72	3	Converged
K=3 mixed	0.84	5	Converged
K=5 adversarial	0.91	8	Converged
K=10 random	0.96	14	Converged

4.5 Invariant Set Existence

Table 5. Invariant set validation (exp_invariants.sx).

Experiment	Steps	Escape Violations	\(d(\theta_T, \Omega)\)
3-subsystem quadratic	20,000	0	3.1e-8
5-subsystem coupled	20,000	0	7.2e-7
10-subsystem random	20,000	0	4.5e-5

4.6 Timescale Separation

Table 6. Timescale separation (exp_timescale.sx).

Subsystem Pair	\(\eta_i / \eta_j\)	Separation Achieved
Fast / Medium	10.0	Yes
Medium / Slow	5.0	Yes
Fast / Slow	50.0	Yes
Equal rates	1.0	Yes (projection handles)

4.7 Convergence Score Validity

4.8 Convergence Rate Bound

Table 7. Convergence score validation (exp_convergence_order.sx).

System	Theoretical Rate	Empirical Rate	Final \(S\)
Cooperative K=3	0.80	0.79	0.9997
Mixed K=5	0.91	0.90	0.9974
Adversarial K=5	0.95	0.94	0.9926

5. Novel Contributions

5.1 Cosine-Scaled Projection

Standard PCGrad (Yu et al. 2020) projects the gradient of task \( i \) onto the normal plane of task \( j \) whenever the inner product is negative. This binary decision ignores the magnitude of the conflict. Our cosine-scaled projection introduces a continuous scaling factor \( |\cos(g_i, g_j)| \), so that near-orthogonal gradients receive minimal correction while antiparallel gradients receive full projection.

The key advantage is that cosine scaling resolves 100% of conflicts in our experiments (500/500), while Riemannian PCGrad resolves only 66.5%. The residual component after projection also acts as implicit exploration (see Section 5.5).

5.2 Normalised Lyapunov Function

Classical Lyapunov analysis requires constructing a function \( V \) specific to each system, a process that becomes intractable as the number of subsystems grows. Our normalised Lyapunov function is system-agnostic: it depends only on the distances from the current state to each subsystem's fixed point, normalised by the initial distances. This eliminates dependence on the dimension \( n \) and the absolute scale of the problem.

The normalisation also makes the Lyapunov decrease rate directly interpretable: \( V = 0.5 \) means the system is, on average, halfway to convergence relative to its starting point. This is invariant across systems of different scales.

5.3 Interaction Matrix

The interaction matrix \( M \) is the central structural object of the framework. Its diagonal entries are individual contraction rates (which are well-studied), and its off-diagonal entries capture pairwise interference through gradient cosines weighted by contraction rates.

The spectral radius \( \sigma(M) \) provides a single scalar that determines whether composition preserves convergence. This replaces the standard approach of analysing each pair of subsystems individually, which scales as \( O(K^2) \) and does not capture higher-order interactions.

A further insight from the experiments (Conjecture 6.8, validated) is that the eigenvectors of \( M \) reveal the coalition structure of the subsystems: clusters of subsystems that are tightly coupled form blocks in the eigendecomposition.

5.4 Higher-Order Convergence Score

The convergence score \( S = 1 - \frac{\Delta_{\text{late}}}{\Delta_{\text{early}}} \) requires no knowledge of the target equilibrium. It uses only the trajectory itself, comparing the average step size in the late phase to the early phase. This makes it applicable as a runtime diagnostic in systems where the fixed point is unknown.

In the chaos detection application (Section 7.2), the score correctly identifies the Feigenbaum boundary in the logistic map without any prior knowledge of the bifurcation structure. The score transitions from \( S \approx 1 \) (convergent) to \( S \leq 0 \) (chaotic) precisely at \( r \approx 3.57 \).

5.5 Implicit Exploration

When the cosine-scaled projection removes the conflicting component of \( g_i \), the residual \( \tilde{g}_i - g_i^{\parallel} \) lies in the null space of the conflict direction. This residual acts as an exploration term: it moves the parameters in a direction that is orthogonal to the conflict axis, which can help the system escape shallow local minima.

The magnitude of this exploration is proportional to \( \sin(g_i, g_j) \), so it is largest when the conflict is at a 45-degree angle and vanishes when the gradients are perfectly aligned or antiparallel. This produces an exploration schedule that is automatically calibrated to the level of disagreement between subsystems.

5.6 Desire as Bayesian Regulariser

This result is counterintuitive: a desire that disagrees with the truth improves the agent's calibration. The mechanism is regularisation in the classical sense. The desire prior prevents the posterior from overfitting to early observations, which are noisy and sparse. As observations accumulate, the Bayesian update dominates and the desire's influence shrinks, but the early regularisation prevents the posterior from collapsing to a point estimate prematurely.

The experiment (exp_anima_deep.sx) validates this across 10,000 Bayesian updating trials: agents with a skeptical desire (opposing the true state) achieve 31% lower calibration error than agents with no desire prior, and outperform agents with a correctly aligned desire by 12%.

6. I-Ratio Theorem and B-Flow

6.1 The Interaction Ratio

The result is exact and dimension-free. It holds for any \( K \geq 2 \), any dimension \( n \), and any gradient magnitudes. The condition \( I = -\frac{1}{2} \) has a geometric interpretation: the cross-term energy is exactly half the self-term energy, with opposite sign. This is the balance point where interference exactly cancels the individual gradient drives.

Table 8. I-ratio validation across configurations (exp_iratio_proof.sx, exp_iratio_proof_statistical.sx).

Test Class	Tests	Pass	Max Error
K=2, analytical	28	28	2.22e-16
K=3, analytical	24	24	4.44e-16
K=5, analytical	20	20	8.88e-16
K=10, random	36	36	1.78e-15
K=100, random	30	30	3.55e-14
Statistical (70 configs)	70	70	1.0e-12

6.2 Balance Residual and B-Flow

The insight is that minimising the total loss \( L = \sum_i L_i \) drives each subsystem toward its own minimum, but these minima may be in tension. Minimising the balance residual \( B \) instead drives the system toward the point where the subsystem gradients cancel, which is the true equilibrium of the composed system. B-flow is thus optimising the right objective.

The two-phase optimisation strategy is: (1) use standard loss-flow to quickly reach a neighbourhood of the equilibrium, then (2) switch to B-flow for high-precision convergence. The switching criterion is \( B(\theta) < \epsilon \) for a chosen threshold \( \epsilon \).

Table 9. B-flow vs loss-flow comparison (exp_balance_residual.sx, exp_equilibrium_mapping.sx).

Method	Final Objective	Final B	Steps
Loss-flow (SGD)	3.3e-4	1.2e-2	10,000
B-flow	4.1e-3	8.8e-16	10,000
Two-phase (5K + 5K)	5.7e-4	2.1e-15	10,000

7. Cross-Domain Applications

7.1 Game Theory (Theorem 11)

In the iterated Prisoner's Dilemma experiment (exp_nash_equilibrium.sx), the interaction matrix formulation discovers a cooperative equilibrium that achieves 83.5% of the Pareto-optimal payoff, compared to 33% for the standard Nash equilibrium (mutual defection). The mechanism is that the interaction matrix captures the full coupling structure, enabling the projection operator to resolve the conflict between individual and collective incentives.

7.2 Chaos Detection (Theorem 12)

Table 10. Chaos boundary detection (exp_chaos_boundary.sx, exp_s_vs_lyapunov.sx).

\(r\)	Regime	\(S\)	\(\lambda\)
2.8	Fixed point	0.998	-0.41
3.2	Period-2	0.872	-0.12
3.5	Period-4	0.541	-0.03
3.57	Onset of chaos	0.003	0.00
3.8	Chaotic	-0.34	0.43
3.83	Period-3 window	0.91	-0.18
4.0	Full chaos	-0.52	0.69

7.3 Generative Adversarial Networks

A GAN is a two-subsystem adaptive composition: the generator \( G \) and discriminator \( D \) share no parameters but interact through the loss. The interaction matrix is \( 2 \times 2 \) with off-diagonal entries determined by the generator-discriminator gradient cosine. When this cosine approaches \(-1\) (mode collapse), the spectral radius exceeds 1 and the I-ratio departs from \(-0.5\).

The convergence score \( S \) applied to GAN training (exp_gan_convergence.sx) provides an early warning of mode collapse: \( S \) drops below 0.5 approximately 500 steps before the discriminator loss diverges, enabling preemptive intervention (e.g., reducing the discriminator learning rate or applying spectral normalisation).

7.4 ODE Solvers and Stiff Systems

Splitting methods for stiff ODEs decompose the right-hand side into fast and slow components, each handled by a specialised integrator. This is a composition of adaptive subsystems with natural timescale separation (C4). The interaction matrix captures the coupling between the fast and slow integrators, and the condition \( \sigma(M) < 1 \) provides a stability criterion that is tighter than the standard CFL condition for the coupled system.

7.5 Financial Markets and Ecosystem Dynamics

Market agents performing gradient-based portfolio optimisation can be modelled as adaptive subsystems on the shared price vector. The I-ratio measures the degree of crowding: when \( I \to -0.5 \), the market is in equilibrium; when \( I \gg -0.5 \), agents are herding (correlated gradients); when \( I \ll -0.5 \), agents are in destructive opposition.

Similarly, in Lotka–Volterra ecosystems, the interaction matrix entries correspond to predator-prey and competitive couplings. The spectral radius condition \( \sigma(M) < 1 \) provides a sufficient condition for stable coexistence.

7.6 Neural Network Gradient Health

In deep networks, each layer can be viewed as an adaptive subsystem. The interaction matrix between layers captures the gradient flow structure, and the I-ratio monitors gradient health during training. In our compiler pass experiments (exp_compiler_passes.sx), treating each compiler optimisation pass as a subsystem and monitoring \( I \) enabled per-program adaptation of the pass schedule, improving compile-time efficiency.

8. Conjectures

The following conjectures arise from the experimental programme. Each is stated precisely and assigned a status based on current evidence.

9. Robustness

The framework's practical utility depends on its sensitivity to parameter choices. We assess robustness along four axes, validated by exp_sensitivity.sx.

9.1 Learning Rate Sensitivity

The main theorem requires \( \eta_i \leq \frac{2}{\mu_i + L_i} \) for each subsystem. Empirically, the framework tolerates learning rates up to 3 orders of magnitude above and below the optimal value. The convergence score \( S \) remains above 0.9 for \( \eta \in [10^{-4}, 10^{-1}] \) in all tested configurations. At \( \eta > 0.5 \), oscillations appear but the system still converges (though more slowly).

9.2 Component Scaling

The normalised Lyapunov function ensures that the analysis is invariant to rescaling of individual subsystem losses. Multiplying \( L_i \) by a constant \( c_i > 0 \) rescales \( g_i \) but does not change the cosine similarities, so the off-diagonal entries of \( M \) are invariant. The diagonal entries scale by \( c_i \), which can change \( \sigma(M) \), but the framework remains valid as long as the contraction rates after scaling satisfy \( \rho_i < 1 \).

9.3 Dimensionality

The convergence rate \( \sigma(M)^t \) is independent of the parameter dimension \( n \). The interaction matrix is \( K \times K \), where \( K \) is the number of subsystems, not the number of parameters. This makes the framework applicable to high-dimensional problems without additional cost. Experiments validated this with \( n \) ranging from 2 to 50 dimensions, with no degradation in the tightness of the spectral radius bound.

9.4 Convergence Speed

Table 11. Convergence speed across configurations.

K	\(\sigma(M)\)	Steps to \(S > 0.99\)	Steps to \(B < 10^{-10}\)
2	0.72	45	230
3	0.84	110	580
5	0.91	280	1,400
10	0.96	720	3,600

Convergence speed scales logarithmically with \( 1/\sigma(M) \), as expected from the geometric rate bound. The practical implication is that systems with \( \sigma(M) > 0.95 \) may require thousands of iterations, while systems with \( \sigma(M) < 0.8 \) converge in under 100 steps.

10. Reproducibility

10.1 Experiment Index

Table 12. Complete experiment index. All experiments implemented in Simplex.

File	Domain	Validates	Key Result
exp_contraction.sx	Core	Theorem 1, Prop 3.1	5/5 subsystems contract
exp_gradient_interference.sx	Core	Theorem 2, Prop 3.2	100% conflict resolution
exp_lyapunov.sx	Core	Theorem 3, Prop 3.3	0 Lyapunov violations
exp_interaction_matrix.sx	Core	Theorem 4, Prop 3.4	Spectral radius converges
exp_convergence_order.sx	Core	Theorem 5, Prop 3.7-3.8	S = 0.9997
exp_invariants.sx	Core	Prop 3.5	0 violations / 20K steps
exp_timescale.sx	Core	Prop 3.6	100% timescale separation
exp_anima_deep.sx	Cognitive	Theorems 6, 7	31% calibration improvement
exp_anima_correlated.sx	Cognitive	Theorem 7	Desire regularisation confirmed
exp_skeptical_annealing.sx	Cognitive	Conj. 6.3, 6.5	Skeptic wins at all horizons
exp_belief_cascade.sx	Cognitive	Conj. 6.4	Chain topology recovered
exp_memory_dynamics.sx	Cognitive	Conj. 6.6-6.10	Optimal forgetting learned
exp_chaos_boundary.sx	Dynamics	Theorem 12	Feigenbaum point detected
exp_s_vs_lyapunov.sx	Dynamics	Theorem 12	S-λ complementarity
exp_nash_equilibrium.sx	Games	Theorem 11	83.5% Pareto-optimal
exp_iratio_proof.sx	Core	Theorem 13	138/138 analytical tests
exp_iratio_proof_statistical.sx	Core	Theorem 13	70/70 statistical tests
exp_balance_residual.sx	Core	Theorem 14	375B× precision gain
exp_iratio_applications.sx	Cross-domain	Theorem 13	5 domains validated
exp_equilibrium_mapping.sx	Optimisation	Theorem 14	B-flow convergence
exp_symmetry_breaking.sx	Core	Conj. 6.2, 6.8	Group structure recovered
exp_sensitivity.sx	Robustness	Props 7.1-7.4	3 OOM stability range
exp_code_gates.sx	Code	Theorem 8	S reaches 0 at step 50
exp_compiler_passes.sx	Compiler	Theorems 9, 10	Per-program adaptation
exp_structure_discovery.sx	Topology	Gradient topology	Constraint graph found
exp_gan_convergence.sx	GANs	Theorems 1, 13	Mode collapse early warning

10.2 How to Run

All experiments require the Simplex compiler. Build from source:

git clone https://github.com/senuamedia/lab.git
cd simplex && ./build.sh
cd ../theorem-proof
./run_all.sh            # Core theorem experiments
./run_math_tests.sh     # 188 compiler math tests

Individual experiments can be compiled and run with:

../simplex/build/sxc exp_iratio_proof.sx -o exp_iratio_proof
./exp_iratio_proof

10.3 Citation

@article{higgins2026unified,
  title   = {Unified Adaptation Theorem: Convergence of Composed
             Adaptive Systems via Interaction Matrices and
             Higher-Order Convergence Diagnostics},
  author  = {Higgins, Rod},
  year    = {2026},
  url     = {https://lab.senuamedia.com/papers/unified-adaptation-theorem.html}
}

References