The Geometry of Sequential Learning: Lie-Bracket Prediction of Transfer Order
Abstract: Sequential learning is order-dependent: from Pile-style next-token domain adaptation to instruction-SFT and DPO, N candidate sources induce N! possible curricula. We show that the local order effect is governed by a computable geometric quantity, the Lie-bracket commutator of gradient update fields, yielding a pairwise score for whether A->B or B->A is better for a target domain. The pairwise bracket primitive also defines a Lie-Bracket Tournament: with a shared theta_0 target-gradient reference, Hessian symmetry gives Borda/row-sum scores from one Hessian-vector product per source, O(N) dot products, and an O(N log N) sort, without materializing the O(N2) edge matrix. Empirically, the planner reaches 98.1%/98.9% pairwise accuracy at k=1 for instruction-SFT/DPO, remains at 73.1%/72.2% at k=20, and preserves the original pretraining-domain evidence with 82.4-92.0% accuracy across four LLMs and 91.1% on diffusion. At curriculum scale, it recovers the best of all 3! schedules in 87.5% of trials, ranks 85 Stack programming-language source domains for a Python target in the 99th sampled percentile, and reaches the 99.0-99.6th sampled percentile on 56 MMLU subjects, sharply above the reported descending gradient-norm baseline. These results reframe sequential learning as a geometric tournament problem: commutators provide both local pairwise order information and a scalable primitive for many-domain schedules.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What this paper is about
When you train a big AI model on several datasets, the order you use matters. Training first on one dataset and then another can lead to a different final model than doing them in the opposite order. This paper shows a simple, math-based way to predict which order will work better for a chosen goal, without trying every possible order. It also turns this “who should go first?” idea into a fast way to plan long training schedules with many datasets.
The big questions the paper asks
- How can we predict, for two datasets A and B, whether training A→B or B→A will give better performance on our target task?
- Can we scale this up to many datasets (like 30, 50, or 80+) without testing all orders, which would be impossibly many?
- Will this approach work for different kinds of training (like instruction tuning, preference optimization, next-token prediction, and even image diffusion)?
- Can we make the prediction fast and cheap enough to be practical?
How the method works (in everyday language)
Think of training as walking on a hilly landscape where the height is “loss” (lower is better). Each dataset gives the model a “push” in a certain direction down the hill:
- A gradient is like pointing downhill from where you stand right now (which way to move to go down fastest).
- A Hessian says how the slope itself changes around you (like how the steepness curves in different directions).
Now, imagine two pushes:
- First push from dataset A, then from dataset B (A→B)
- Or first push from B, then from A (B→A)
On flat ground, doing A then B or B then A would end in the same place. But the learning landscape is curved, so the order makes a difference. The paper captures this “order difference” with a geometric quantity called a “Lie bracket” (you can think of it as a smart way to subtract “A→B” from “B→A” to see how different they are).
Here’s the core idea in simple steps:
- Compute each dataset’s “push” at the current model: its gradient.
- Estimate how that push will bend because the landscape curves: a Hessian–vector product (this tells you how the slope changes in the direction of another dataset’s push).
- Combine those to get a “bracket vector” that predicts how much A→B will differ from B→A.
- Aim this difference at your target task: check whether this difference helps or hurts your target loss. If it points in a good direction for the target, that order is better.
Two practical tricks make this work well and stay fast:
- Drift-matched reference point: Instead of measuring the target direction only at the start, they measure it at a smart “shared drift” point that both orders would move toward after their first nudges. This reduces error without simulating both orders.
- Small subspace: They do these calculations only in the parts of the model you actually plan to fine-tune (like the last layer), which is much cheaper but still informative.
Turning pairs into a plan for many datasets:
- Treat each pair of datasets like a “match” that says who should go earlier.
- This forms a “tournament” over all datasets.
- Instead of building all pairwise scores (which would be slow), they use a neat shortcut: for each dataset, compute one Hessian–vector product with the target, plus gradients. With a few sums and dot products, you get a simple score (a “row-sum/Borda” score) for each dataset. Sort by that score and you have a curriculum (an order to train).
Two helpful extras:
- A stakes score estimates how much the order matters for your target (big stakes → choose carefully).
- A confidence score tells how sure the method is about the sign of the prediction (if confidence is low, either order probably works similarly).
What they found and why it matters
Highlights from their experiments across different training types and models:
- Two-dataset order prediction is highly accurate at short horizons:
- Instruction-tuning (SFT): about 98% accuracy for deciding A→B vs B→A with just one step.
- Preference optimization (DPO): about 99% accuracy with one step.
- Classic next-token domain adaptation (several LLMs): around 82–92% accuracy.
- Diffusion model (for images): about 91% accuracy.
- Still helpful when training goes longer:
- Even when each dataset is trained for many steps (up to 50 per dataset), a single initial prediction often stays right much more than chance (e.g., ~81% at 20 steps, ~65% at 50 steps in a large study).
- Planning big curricula without brute force:
- For 3 datasets, the method picked the best of all 6 orders about 88% of the time.
- For big sets (like 56 or 85 domains), the tournament ranking reached the 99th percentile compared to 500 random schedules, beating simple baselines that sort by gradient size.
- Fast and practical:
- The planner becomes faster than trying both orders once you’d otherwise train about 3 steps per dataset.
- It only needs gradients and a few Hessian–vector products in a small part of the model.
In short: the method correctly predicts good orderings, scales to many datasets, and saves a lot of trial-and-error training time.
Why this is important
- Saves compute and time: Instead of testing many orders, you can plan a good one quickly.
- Works across tasks: From language instruction tuning and preference tuning to next-token training and diffusion, the same idea applies.
- Helps avoid performance drops: If you care about a particular capability (like reasoning or safety), you can set that as the “target” and choose the order that protects it better.
- Scales to many domains: The “tournament” trick turns an impossible -order search into a simple ranking with roughly one second-order calculation per dataset.
A simple wrap-up
Training order matters because learning on a curved landscape means “A then B” is not the same as “B then A.” This paper measures that difference with a small, smart calculation—the Lie bracket—and uses it to decide which order helps your target most. It works well in many settings, is fast, and scales to lots of datasets. That makes it a practical tool for anyone building models that must be trained in stages, whether for better performance, faster iterations, or safer capability preservation.
Knowledge Gaps
Below is a single, concrete list of the paper’s unresolved knowledge gaps, limitations, and open questions that future work could address.
- Formalize augmented-state commutators for stateful optimizers (e.g., Adam/AdamW with momentum, EMA statistics, weight decay), and derive deployable estimators and cost-effective HVP analogs in the expanded state space.
- Provide theoretical error bounds and sign-stability conditions for multi-step horizons (), including BCH-based higher-order terms under repeated compositions and criteria for when a single-shot predictor remains valid as training proceeds.
- Quantify and mitigate stochastic estimation error: analyze variance and sample complexity for gradient/HVP minibatches with independent draws (rather than shared batches), and design robust estimators or averaging schemes that achieve target sign-accuracy at practical batch sizes.
- Address parameterization and preconditioning dependence: characterize how the bracket and rankings change under reparameterizations, adaptive preconditioners, natural gradient metrics (Fisher–Riemannian geometry), and optimizer-specific scalings.
- Systematically study sensitivity to the chosen trainable subspace S: develop principled methods to select or learn S (e.g., via influence functions or sensitivity analysis), and validate in common parameter-efficient regimes (LoRA/adapters) beyond final-layer and 8-layer subsets.
- Enable stable, scalable HVPs through attention and normalization layers in large models and mixed precision: evaluate and integrate distributed HVPs, Hessian approximations (e.g., K-FAC, block-diagonal, low-rank), and libraries such as HessFormer, with quantified accuracy–cost trade-offs.
- The shared-reference tournament choice trades accuracy for scalability; quantify when this induces ranking errors versus pair-specific drift-matched references, and explore hybrid references (cluster- or band-specific) that preserve near-linear cost.
- Characterize and control tournament intransitivity: provide theoretical conditions under which bracket-induced edges are (approximately) transitive, design tie-breaking/regularization for cyclic cases, and analyze sensitivity of Borda rankings to noisy or near-zero edges.
- Calibrate and validate the stakes score s = : assess how well predicted magnitudes track true , provide confidence intervals, and develop calibration procedures or Bayesian models to improve effect-size prediction.
- Normalize domain scaling: develop and evaluate strategies to handle disparate domain sizes, loss scales, and curriculum weights (per-example normalization, temperature scaling), so that bracket edges are not dominated by scale rather than transfer relevance.
- Extend from pure sequential blocks to mixed/interleaved curricula: formulate how commutators inform mixing proportions, interleaving frequency, or time-varying schedules, and compare against mixture-of-domains training.
- Plan for multi-target objectives (e.g., capability preservation and downstream metrics): extend pairwise and tournament scoring to multi-objective settings (Pareto, scalarization, or constrained optimization) and study trade-offs between protected losses and target gains.
- Generalize to online RLHF and policy-dependent objectives: incorporate on-policy sampling effects, KL constraints, and reward-model drift into the bracket framework; derive analogous commutators and references for preference-based or reinforcement objectives.
- Broaden empirical scope: evaluate on larger foundation models (≥70B), multilingual/multimodal tasks, diverse vision and speech settings, and more complex diffusion or generative pipelines to test scalability and cross-domain robustness.
- Scale to very large N (hundreds–thousands of sources): develop sampling, clustering, or bandit-style selection to reduce the number of HVPs, and incremental/update-efficient tournament maintenance as sources are added.
- Assess numerical stability in realistic training stacks: study effects of mixed precision, gradient clipping, LayerNorm/statistics updates, dropout, and microbatching on bracket estimation and sign reliability.
- Clarify and simplify the step-size autopilot: provide formal guarantees for detectability vs. sign-validity constraints, characterize sensitivity to pilot-set selection, and explore lighter-weight heuristics with comparable performance.
- Tighten theoretical treatment for projected updates: extend proofs and practical recipes to include common training extras (weight decay, gradient clipping, EMA) and analyze whether projected Hessian symmetry assumptions still yield reliable tournament identities.
- Explore alternative tournament aggregations: compare Borda to Kemeny-optimal rankings or local-search over permutations using the surrogate score, and analyze when alternative aggregations offer better robustness to noisy/near-zero edges.
- Handle non-smooth or piecewise-smooth objectives: extend bracket definitions and estimators to subgradient regimes (e.g., hinge losses, ReLU kinks) via generalized derivatives or smoothing, with error bounds.
- Account for data augmentation and training-time randomness: model the bracket under augmentation distributions, quantify how augmentations alter gradient/Hessian estimates, and evaluate augmentation-aware planning.
- Detect and handle degenerate/near-identical domains: develop diagnostics for near-zero brackets (indifference), gating rules for low-confidence edges, and fallbacks when either order is effectively equivalent.
- Improve second-order approximation practicality: investigate curvature proxies (e.g., K-FAC, low-rank Kronecker, Nyström) that retain sign accuracy while reducing HVP cost and memory, and quantify the observed 4–12pp accuracy gap to exact HVPs.
- Integrate regularization effects explicitly (weight decay, auxiliary penalties): derive how such terms modify and , and assess whether including them improves predictive accuracy and stake calibration.
Practical Applications
Immediate Applications
Below are actionable uses you can deploy now, derived from the paper’s bracket-based planner, its drift-matched estimator, and the Lie-Bracket Tournament for large-N scheduling.
- LLM post-training order selection (instruction-SFT and DPO)
- Sectors: software/AI platforms, consumer AI assistants, enterprise AI
- What to do:
- Use the pairwise Lie-bracket planner to choose A→B vs B→A for instruction SFT or DPO phases. Empirically effective at k=1 (≈98% sign accuracy) and still strong at k=20 (≈72%).
- Apply stakes (η²|σ|) and confidence (|ω|) to gate when to trust the decision and how much the order matters.
- Tools/workflows:
- Add a “Curriculum Planner” step to your Hugging Face/Lightning/DeepSpeed fine-tuning scripts that computes: gA, gB, two HVPs (HBgA and HAgB), target gradient at the Trotter point, then predicts the order with stakes/confidence.
- In PEFT/LoRA regimes, compute in the trainable subspace (e.g., last layer o_proj/down_proj); one HVP per direction is enough.
- Assumptions/dependencies:
- Access to per-domain gradients and HVPs; twice-differentiable loss.
- Locality: short-horizon approximation is most accurate; accuracy degrades gradually but remains useful up to 20–50 steps.
- Optimizer: theory assumes memoryless updates (e.g., SGD); works reasonably under AdamW but with reduced reliability.
- Large-N curriculum ranking via Lie-Bracket Tournament
- Sectors: education (subject-tuned LLMs), software (code models), general model adaptation
- What to do:
- Rank tens to 80+ domains by Borda/row-sum using one HVP per source with a shared target-gradient reference, then sort O(N log N).
- Use this ranking to set a one-pass curriculum without testing N! orders.
- Tools/workflows:
- Implement Algorithm 2 (Tournament) with shared gE(θ0), compute per-domain gi and ui=Hi gE, aggregate r_i=G⋅ui−gi⋅U, sort.
- Visualize scores to audit edge cases and potential cycles.
- Assumptions/dependencies:
- Shared-reference edges (θ0) favor scalability over pair-specific accuracy; still performed at the 89–99.6th sampled percentiles on MMLU/Stack in the paper.
- Per-domain batches consistent across evaluations to control noise.
- Capability preservation/safety gating during fine-tuning
- Sectors: healthcare, finance, safety-critical AI, policy/compliance
- What to do:
- Treat a protected capability P as the “target” E and use the bracket sign to select an order that minimizes loss on P (preserves capability).
- Gate high-risk sequences by stakes/confidence; insert rehearsal/safety data as a domain in the tournament when needed.
- Tools/workflows:
- “Protected loss” hook that computes gP at the Trotter point and vetoes orders with large predicted harm (high stakes, confident sign).
- Assumptions/dependencies:
- Protected objectives must be expressible as differentiable losses with adequate validation sets.
- Thresholds for stakes/confidence require governance policies.
- Diffusion model adaptation schedules
- Sectors: creative media, design tools, advertising
- What to do:
- Use the same bracket planner to choose or rank adaptation orders across styles/classes. The paper reports ≈91% accuracy and perfect accuracy on high-impact cases.
- Tools/workflows:
- Compute HVPs on UNet convolution blocks (for stability), apply pairwise planner or tournament ranking for multiple classes/styles.
- Assumptions/dependencies:
- Differentiable diffusion losses and stable float32 HVPs; maintain consistent noise schedules/batches when comparing orders.
- Compute- and time-efficient A/B order screening
- Sectors: MLOps, cloud/HPC, sustainability
- What to do:
- Replace brute-force AB and BA trials with a single planner call. Planning is already cheaper than evaluating both orders around k≈3–4 and up to ≈13× faster at k≈20 in reported wall-clock.
- Tools/workflows:
- Integrate “Plan-then-Train” in orchestration: run planner, log stakes/confidence, train only the chosen order.
- Assumptions/dependencies:
- Reliable HVP implementation (Pearlmutter), float32 where needed for stability; subspace restriction to keep HVPs affordable.
- Academic diagnostics for task interference and order effects
- Sectors: academia, research labs
- What to do:
- Use bracket vectors (bAB) and target alignments (gE⋅bAB) to analyze non-commutativity between tasks, interpret forgetting/transfer effects, and design curricula for multi-task studies.
- Tools/workflows:
- Add bracket logging dashboards; correlate |ω| with observed order sensitivity ΔE for interpretability studies.
- Assumptions/dependencies:
- Reproducible minibatching; controlled η via the provided η-autopilot or small grid search.
- Cost-aware LoRA/adapters ordering for small labs and hobbyists
- Sectors: daily life/open-source
- What to do:
- For home GPUs, run final-layer or LoRA-only brackets to pick the order of datasets (e.g., SQL first, then Python) before a multi-task fine-tune.
- Tools/workflows:
- Lightweight “Bracket Planner” plugin for Hugging Face Trainer with optional UI for stakes/confidence.
- Assumptions/dependencies:
- Small subspace HVPs fit on consumer GPUs; minimal code changes to compute HVPs in the trainable layer(s).
Long-Term Applications
These opportunities require additional research, scaling, or productization beyond the current paper’s scope.
- Optimizer-aware (augmented-state) commutators for AdamW and beyond
- Sectors: software/AI, foundation-model training
- Potential:
- Extend the bracket to optimizer states (θ, m, v) to improve long-horizon and AdamW reliability; aim for >60% at k≥20–50 with stateful optimizers.
- Tools/workflows:
- New HVP-like primitives for optimizer-state Jacobians; planner hooks that consider momentum/variance states.
- Assumptions/dependencies:
- Theory and systems support for augmented-state Lie brackets; efficient autodiff over optimizer states.
- Dynamic curricula and online RLHF
- Sectors: alignment, safety, production RLHF
- Potential:
- Use bracket edges to adaptively reorder domains during training or to schedule online preference data collection; extend from offline DPO to interactive pipelines.
- Tools/workflows:
- Controller that recalculates edges periodically and updates data sampling or order; integrates with preference data acquisition.
- Assumptions/dependencies:
- Stable online estimators under non-stationary data; budget-aware compute for periodic HVPs.
- Task-mixture design: from ordering to weighting/sampling policies
- Sectors: multi-task learning, multilingual systems, MoE
- Potential:
- Convert pairwise bracket signals into continuous sampling weights or curriculum pacing, not just an order; handle partial overlaps and re-entries.
- Tools/workflows:
- Bracket-to-weight mapper; pacing schedules that prioritize strongly positive edges early.
- Assumptions/dependencies:
- New theory linking pairwise commutators to steady-state mixing; stability under stochastic sampling.
- Foundation-model pretraining at scale
- Sectors: large-scale AI, cloud providers
- Potential:
- Use large-N tournaments to schedule hundreds of pretraining sources to preserve downstream capabilities and avoid catastrophic forgetting.
- Tools/workflows:
- Distributed HVP services; streaming tournament updates; integration with data catalogs.
- Assumptions/dependencies:
- Scalable, stable HVPs on trillion-parameter models; careful numerical precision; robust batching policies.
- Multi-modal and robotics curricula
- Sectors: robotics, AV, vision-language-action systems
- Potential:
- Apply bracket scheduling to multi-task policies (e.g., grasping, navigation) and multi-modal encoders; reduce negative transfer by principled ordering.
- Tools/workflows:
- Differentiable control losses and HVPs over policy networks; tournament ranking across skill datasets.
- Assumptions/dependencies:
- Reliable second-order info for RL/control losses; safe domain transitions in physical systems.
- Standardization and governance of training order reporting
- Sectors: policy, compliance, audits
- Potential:
- Establish best practices to disclose and justify dataset order via bracket-based evidence; track “stakes” to highlight high-risk transitions and protected capabilities.
- Tools/workflows:
- Audit tools that record tournament scores and chosen curricula with confidence thresholds; compliance dashboards.
- Assumptions/dependencies:
- Community and standards-body adoption; alignment with privacy/IP constraints for gradient computations.
- Sustainability: compute-aware planning and emissions reduction
- Sectors: energy, ESG reporting
- Potential:
- Quantify and report compute savings from planning vs brute-force curricula; integrate into green AI metrics.
- Tools/workflows:
- MLOps telemetry that logs avoided AB/BA runs and estimated energy savings.
- Assumptions/dependencies:
- Accurate lifecycle accounting; organizational incentives for ESG disclosures.
- Bracket-guided parameter updates (beyond selection)
- Sectors: research, advanced optimization
- Potential:
- Use the bracket direction to perform small corrective moves after shared drift (paper’s control ablation suggests promise), evolving toward bracket-aware optimizers.
- Tools/workflows:
- Hybrid first/second-order updates that include a bracket term in each phase.
- Assumptions/dependencies:
- Stability analyses and training heuristics to prevent divergence; efficient computation of bracket terms at scale.
- Open-source SDKs and developer tools
- Sectors: developer tooling, platforms
- Potential:
- Package an SDK with: HVP subspace utilities, η-autopilot, pairwise planner, tournament ranker, and BracketViz dashboards for edges/stakes/confidence.
- Tools/workflows:
- Plugins for PyTorch Lightning, Hugging Face Trainer, Ray/Vertex AI pipelines.
- Assumptions/dependencies:
- Ongoing maintenance for model architectures and precision modes; community contributions to new modalities and tasks.
Glossary
- AdamW: An adaptive optimizer that decouples weight decay from the gradient update, maintaining optimizer state across steps. "AdamW is a stateful optimizer, while the clean derivation applies to memoryless gradient-style updates."
- Baker–Campbell–Hausdorff (BCH) expansion: A series formula describing how exponentials of non-commuting operators combine; it exposes commutator terms governing order effects. "the same commutator term that appears in the Baker--Campbell--Hausdorff (BCH) expansion~\citep{baker1905alternants,campbell1897law,hausdorff1906symbolische} for continuous-time flows also governs the order sensitivity of discrete gradient steps (to second order)."
- Borda/row-sum score: A ranking rule from voting theory that sums a node’s pairwise edge weights to produce an overall order. "We rank this tournament by the classical Borda/row-sum score~\citep{borda1781memoire,brandt2016handbook}:"
- Commutator: An operator measuring non-commutativity, typically [A,B] = AB − BA; here it captures order dependence of updates. "We show that the local order effect is governed by a computable geometric quantity, the Lie-bracket commutator of gradient update fields, yielding a pairwise score for whether or is better for a target domain."
- Confidence gating: A practice of using a confidence metric to decide whether to act on a prediction (e.g., only when alignment is strong). "Confidence gating."
- Coordinate subspace: A selected subset of parameter coordinates used for computation and updates, often for parameter-efficient fine-tuning. "Let denote the coordinate subspace of trainable parameters and the corresponding fixed linear projection."
- DDPM UNet: A UNet architecture trained within a Denoising Diffusion Probabilistic Model (DDPM) framework for generative modeling. "Fourth, we evaluate a DDPM UNet~\citep{ho2020denoising} on class-conditioned diffusion adaptation."
- Direct Preference Optimization (DPO): A preference-learning objective that directly optimizes a model to prefer chosen responses over rejected ones. "We use UltraFeedback source domains~\citep{cui2023ultrafeedback} and the DPO loss~\citep{rafailov2023dpo}, excluding within-flan_v2 pairs that share provenance and create near-degenerate brackets."
- Directional bracket score: The scalar σ that projects the bracket vector onto the target gradient to predict which order reduces target loss. "We connect the order-dependent target-loss difference to the directional bracket score $\sigma_{AB}^{(E)}={g_E}{b_{AB}$ and show that its sign predicts whether or yields lower target loss."
- Drift-matched (Trotter) estimator: An estimator that evaluates the target gradient at a shared-drift reference point to reduce error from target-gradient drift. "We introduce a drift-matched Trotter estimator for using gradients and Hessian-vector products in a chosen trainable parameter subset, together with stakes and confidence scores."
- eta-autopilot: An automated procedure for selecting the learning-rate/step-size η based on detectability and stability criteria. "We develop an automated -autopilot that selects step sizes from pilot data by balancing detectability against higher-order sign-stability constraints, avoiding manual per-model tuning."
- Gradient flow (vector field): The continuous-time dynamical system defined by dθ/dt = −∇L(θ), representing infinitesimal gradient descent. "Let and be the gradient-flow vector fields."
- Hessian: The matrix of second derivatives of a scalar loss with respect to parameters, capturing local curvature. "Assume their Hessians are locally Lipschitz near ;"
- Hessian symmetry: The property H = Hᵗ for twice-differentiable scalar losses, enabling computational simplifications. "The main computational identity is Hessian symmetry."
- Hessian–vector product (HVP): The product Hv computed without explicitly forming H, typically via automatic differentiation tricks. "It only requires two Hessian--vector products (HVPs), and , computed with respect to the parameters we actually fine-tune."
- Lie bracket: For vector fields f_A and f_B, the bracket [f_A, f_B] = ∇f_B f_A − ∇f_A f_B; here equal to H_B g_A − H_A g_B. "This is the same geometric phenomenon that appears in operator splitting and numerical dynamics, where the leading-order error is governed by a commutator, or Lie bracket~\citep{hairer2006geometric}."
- Lie-Bracket Tournament: A weighted tournament over domains whose edges come from bracket-based pairwise preferences used to produce a curriculum. "The pairwise bracket primitive also defines a Lie-Bracket Tournament: with a shared target-gradient reference, Hessian symmetry gives Borda/row-sum scores from one Hessian-vector product per source, dot products, and an sort, without materializing the edge matrix."
- Lipschitz (locally Lipschitz): A smoothness condition bounding how fast a function (or its derivatives) can change in a neighborhood. "Assume their Hessians are locally Lipschitz near ;"
- Mean value theorem: A calculus result ensuring that a function’s change over an interval equals its derivative at some intermediate point times the interval length. "By the mean value theorem,"
- Non-commutativity: The property that the composition of two operations depends on the order in which they are applied. "gradient norm is not target-conditioned, whereas the bracket edge uses the target projection of non-commutativity."
- Operator splitting: Numerical methods that decompose complex dynamics into simpler sub-operators applied in sequence, with errors governed by commutators. "This is the same geometric phenomenon that appears in operator splitting and numerical dynamics, where the leading-order error is governed by a commutator, or Lie bracket~\citep{hairer2006geometric}."
- Pearlmutter's trick: An automatic differentiation method to compute HVPs efficiently as Hv = ∇(∇L * v). "The HVP uses Pearlmutter's trick~\citep{pearlmutter1994fast}: "
- Projected updates (projection operator): Gradient updates restricted to a chosen parameter subspace via a linear projection operator. "All statements in this section hold verbatim for projected updates , where is a fixed linear projection"
- Shared first-order drift: The common first-order parameter change induced by both orders, here −η(g_A + g_B), used to define a better reference point. "A key observation is that both orders share a common first-order drift from "
- Skew-symmetric (matrix): A matrix W with W_{ij} = −W_{ji}; in tournaments this encodes antisymmetric pairwise preferences. "The matrix is skew-symmetric up to stochastic estimation error and defines a weighted tournament over the source domains."
- Stakes score: A scalar estimating the magnitude of the order effect on the target loss, s ≈ η²|σ̂|. "Accordingly, we define the predicted stakes score"
- Trotter reference: The single-point reference θ_ref derived from the Trotter product formula to approximate the shared drift of two orders. "Trotter reference (single-point at $\theta_{\mathrm{ref}$)~\citep{trotter1959product}."
- Weighted tournament: A directed complete graph with weighted edges representing pairwise preferences, used here to rank multiple domains. "The matrix is skew-symmetric up to stochastic estimation error and defines a weighted tournament over the source domains."
Collections
Sign up for free to add this paper to one or more collections.
