The first thing worth saying is that this paper is not our competitor, and pretending otherwise would be the kind of overclaim we built this project to avoid. Li and Zhe are solving a concrete problem in scientific machine learning: how to learn a solution operator for a partial differential equation when the domain is irregular and the training data is scarce. Their answer, GOLA, is a real model with real numbers behind it. We are doing something different — composing language-model behavior out of tiny, swappable adapters. Different field, different units, different evening.
And yet when you set the two side by side, they turn out to be reaching for the same idea from opposite ends of the building. Both of them decide that the interesting thing to learn is not a single monolithic function but the operator that composes simpler pieces into it. That shared instinct is worth taking seriously, because it is also where the difference in approach becomes clear — and where, honestly, we think ours buys something theirs does not, at the price of something theirs has and ours does not yet.
GOLA learns a mapping between function spaces by chaining three stages: a learnable Fourier encoder that lifts irregularly-sampled points into frequency space, message-passing graph networks that capture local spatial structure, and multi-head attention for global context. The authors write the whole model as a single composition —
𝒢θ = 𝒟θ ∘ ℱθ ∘ 𝒯N — decode ∘ Fourier-encode ∘ sample.They prove a proposition that this architecture can approximate the true operator arbitrarily well in the L²(Ω) norm, and they back it with benchmarks: across Darcy Flow, Advection, Eikonal, and Nonlinear Diffusion, on as few as 100 training samples, GOLA beats established baselines — DeepONet, FNO, the Graph Kernel Network — by margins reaching roughly 58% error reduction on the hardest case. It is a clean, well-validated piece of work. The honest headline is: they trained one carefully-composed operator and showed it generalizes from little data.
Look again at that composition arrow. GOLA’s power does not come from any one of its three stages — it comes from the ∘ that binds them. The paper is, in effect, an argument that the shape of the composition is where the modeling leverage lives. That is precisely the premise of the Sparse Model Nexus. Our whole system is an algebra of composition operators over minimal model units we call quanta:
⊕mixture (blend quanta) ·∘sequential (chain them) ·▷route (dispatch by predicate) ·⊗merge (task-arithmetic into one new quantum)
And here is the small, genuine surprise that makes the comparison more than a metaphor: GOLA’s entire model is an instance of our ∘ operator. A fixed three-stage sequential chain, 𝒟 ∘ ℱ ∘ 𝒯, is exactly one point in the Nexus algebra — the point where you pick the sequential operator, pick three quanta, and freeze the choice at design time. We are not claiming to have subsumed their result; their quanta (a Fourier operator, a GNN) are far more sophisticated than our toy adapters. We are claiming something narrower and, we think, more interesting: the object they hand-designed once is a value our framework is built to compute, and re-compute.
GOLA’s arrow is settled before training and never moves. Ours is chosen at deployment. Given a workload frame — its domain, its quality target, its cost and hardware budget — the Nexus plans which operator and which quanta to assemble, and can rebuild that choice when the workload drifts. A fixed pipeline is the right tool when the problem is stationary, as a single PDE family is. It is the wrong tool when tomorrow’s traffic is code in the morning and biology in the afternoon. We built the planner because the future is not stationary.
This is the part most operator-learning work simply does not ask: given what I expect to face next, and what it will cost me, which composition should I deploy right now? Our receding-horizon planner answers it online — forecasting the near-term workload from a short belief window, picking the cheapest composition that still clears the quality bar, caching that choice while conditions hold and re-planning when they break. We ran it over a modeled twelve-frame day and measured the result: it matched a clairvoyant hindsight oracle on total cost, met its quality target 83% of the time, and reused its cached plan on half the frames. The two misses were not bugs; they were the honest price of an unforeseeable shift.
GOLA reports its computational complexity as an 𝒪(·) aside at the end. For us, the active-quanta footprint is the thing being minimized — the “sparse-limit” in the name is the whole point. Every composition the planner picks is the cheapest one that still works. When you deploy models for a living rather than to prove a theorem, that inversion of priorities is not cosmetic.
This is the one we care about most. GOLA states a universal-approximation proposition: the architecture can approximate the target operator arbitrarily well. That is a legitimate and valuable guarantee for a single fixed operator. We make no analogous claim for composed capability — and here I want to be careful, because the site has over-reached on exactly this point. Whether assembling quanta yields a predictable colimit of their abilities is, in practice, hard to predict — no free lunch over unknowable future workloads, and emergence we can’t certify in advance. But calling that “undecidable” in the formal sense, or invoking Tarski’s theorem, dresses a reasonable engineering caution in mathematics it hasn’t earned. Tarski’s undefinability theorem is about a formal language defining its own truth predicate; it does not prove adapter composition undecidable. So: we refuse the guarantee, we report measured regret instead of a proof, and we call the leftover a “Tarski residual” as a loose label for unmodeled uncertainty + distribution shift — not a theorem this experiment established.
| Dimension | GOLA (2505.18923) | Sparse Model Nexus |
|---|---|---|
| Domain | PDE operator learning, irregular 2D domains | LLM behavior via composable LoRA quanta |
| Composition | Fixed chain 𝒟∘ℱ∘𝒯, frozen at design | Runtime-chosen algebra ⊕ ∘ ▷ ⊗ |
| Adaptation | Train once, deploy fixed | Receding-horizon re-planning per frame |
| Cost model | 𝒪(·) noted as an aside | Active-footprint is the objective |
| Guarantee | Universal approximation (proven) | Refused by design; measured regret instead |
| Epistemics | Confident approximation claim (proven) | Emergence treated as unpredictable; uncertainty named loosely (“Tarski residual” — not the theorem) |
| Evidence today | SOTA benchmarks vs 4 baselines | Proof-of-mechanism on distilgpt2 |
| Provenance | Paper + code | Self-describing knowledge graph, every step recorded |
We have not beaten GOLA at anything GOLA does, and we are not going to pretend we have. Two bold cells in that table are theirs, and they are the two that a reviewer should weigh most heavily today. Their model is validated against strong baselines with proper error metrics; our current instantiation is a proof-of-mechanism trained on eight sentences per domain over distilgpt2 — it demonstrates that the machinery runs and that the planner behaves as designed, not that it is state of the art at anything. And they offer a guarantee where we offer an argument for why the guarantee is unavailable; a proof in hand beats a principled refusal, if what you need is a proof.
The measured finding from our own run is equally unflattering and equally honest: with adapters this small, a code specialist already half-generalizes to biology, so our fancier operators (merge, mixture) are dominated by plain routing. The advantage of the algebra shows up only when the quanta are strong and genuinely distinct — which is exactly the next thing to build, and exactly the kind of quantum GOLA itself could be.
The generous reading — and we think the correct one — is that GOLA is a candidate quantum. A validated domain operator with a clean sequential composition is precisely the sort of specialist the Nexus is built to hold, route to, and compose with others under a budget. Their contribution is a strong piece to place on the board; ours is the algebra and the planner that decide when to place it. The paper made one operator learn from limited data and proved it approximates. We are trying to make the choice among operators learnable, cheap, and honest about its own horizon. Those are not the same project, and they are better together than apart.
The realized planner & its measured regret Operator demo ⬇ Model + planner (.zip)