Warm Starting

Warm starting directly addresses the core challenge of iterative solvers like those used for Linear Complementarity Problems (LCPs). Instead of starting each time step's solve from zero (a 'cold start'), it uses the impulse or force vector from the previous converged solution as the initial guess. This is effective because physical interactions are temporally coherent; contact states and forces change incrementally between frames.

• Key Benefit: Drastically reduces the number of iterations required for the solver (e.g., Projected Gauss-Seidel, Sequential Impulse) to converge to a new valid solution.
• Analogy: Similar to using the previous frame's solution as a 'prior' for the current optimization.

By providing a high-quality initial guess close to the final solution, warm starting improves the numerical stability of the simulation. It helps prevent solver divergence and reduces erratic, 'jittery' behavior in contact forces, which is critical for stable robotic control.

• Mitigates Ill-Conditioning: Problems with many simultaneous contacts or high friction coefficients can be numerically stiff. A good initial guess guides the solver through a more stable convergence path.
• Predictable Performance: Enables more consistent and predictable solver iteration counts per frame, which is essential for real-time and hardware-in-the-loop (HIL) applications where computational deadlines are strict.

This technique is fundamentally predicated on the principle of temporal coherence in physical systems. The configuration of rigid bodies, their velocities, and their contact points do not change arbitrarily between simulation time steps (typically 1ms to 10ms).

• Continuity Assumption: The physics solver assumes the solution is a continuous function of time. The impulse from the last frame is a valid first-order approximation for the current frame.
• Edge Case Handling: The solver must still robustly handle the sudden creation or breaking of contacts (e.g., an object hitting the ground). Warm starting values for new contacts are typically initialized to zero, while broken contacts are simply removed from the active constraint set.

Warm starting is a standard feature in modern impulse-based and velocity-level constraint solvers. It is tightly integrated with the solver's data structures, which maintain a cache of manifold information (contact points, normals, friction directions) and their associated Lagrange multipliers (the solved impulse magnitudes).

• Solver Persistence: The cached solution is often stored in a warm start buffer. This buffer is managed across frames, with values being updated, added for new contacts, or purged for lost contacts.
• Complementarity Conditions: The warm-started impulses must still satisfy the complementarity conditions of the LCP (e.g., non-penetration, non-adhesion). The iterative solver's job is to correct and adjust this initial guess to satisfy these conditions for the new configuration.

In the context of sim-to-real transfer learning for robotics, warm starting is a critical performance optimization. Training reinforcement learning policies requires millions to billions of simulation steps. Even a small reduction in per-step computation compounds significantly.

• Throughput for Parallel Training: Faster solver convergence directly increases the sample throughput of parallelized simulation infrastructure, accelerating policy training cycles.
• Enabling Higher Fidelity: The computational savings can be reallocated to increase simulation complexity, such as adding more simulated robots, higher-precision collision detection, or more detailed friction cone approximations, without sacrificing real-time performance.

Understanding warm starting is clarified by contrasting it with the default alternative.

• Cold Start: Every time step, the solver initializes all impulse variables to zero. It must 'discover' the solution from scratch each frame, leading to maximum iteration counts and higher computational cost. This is robust but inefficient.
• Warm Start Trade-off: Introduces a minor memory overhead to store the previous solution but provides substantial computational savings. The primary engineering consideration is correctly invalidating or resetting the warm start cache when discontinuous events (like teleportation or major state resets) break the assumption of temporal coherence.

This is the canonical application. In rigid body dynamics and contact resolution, the solver (e.g., solving a Linear Complementarity Problem) uses the impulse solution from the previous frame as the initial guess. This drastically reduces the number of iterations needed for convergence, enabling real-time simulation of complex scenes with many contacts. It is foundational for robotic manipulation and articulated body dynamics simulations.

In Model Predictive Control, an optimal control sequence is computed over a receding horizon at each control step. The optimization problem is highly similar from one step to the next. Warm starting the solver with the previous step's solution (shifted in time) provides an excellent initial guess, reducing solve time and enabling higher-frequency control loops for autonomous vehicles, drones, and industrial robots.

Algorithms for planning smooth, collision-free paths—such as CHOMP, STOMP, or direct collocation methods—solve non-convex optimization problems. When planning is done in a replanning or model-predictive context, or when optimizing a trajectory iteratively, warm starting with the previously optimized path provides a strong initial condition, helping avoid local minima and speeding up convergence.

Beyond real-time simulation, warm starting is a general technique in Sequential Quadratic Programming (SQP) and interior-point methods. When solving a sequence of related Nonlinear Programming (NLP) problems—such as in parameter estimation, design optimization, or economic dispatch—the primal variables, dual variables (Lagrange multipliers), and Hessian approximations from a solved instance provide a superior starting point for the next.

In Mixed-Integer Programming, warm starts provide an initial feasible integer solution (an incumbent) to the solver. This gives the branch-and-bound algorithm an upper bound immediately, allowing it to prune large sections of the search tree early. This is invaluable in industrial scheduling, logistics, and planning problems where similar problem instances are solved repeatedly with minor data changes.

In incremental learning or online learning scenarios for Support Vector Machines, the model is retrained as new data arrives. Warm starting the quadratic programming solver used in SVM training with the support vectors and Lagrange multipliers from the previous model significantly accelerates retraining, making adaptive SVM systems more practical.

The constraint solver is the algorithmic core of a physics engine that calculates the forces or impulses necessary to satisfy a set of constraints—such as contact non-penetration or joint limits—within a numerical tolerance over a series of iterations. It is the component that warm starting directly accelerates.

• Iterative Methods: Solvers like Projected Gauss-Seidel (PGS) or Sequential Impulse solve constraints incrementally.
• Convergence: The goal is for the solution to converge to a state where all constraints are satisfied. Warm starting provides a better initial guess, reducing the number of iterations needed for convergence.

A Linear Complementarity Problem is a mathematical formulation used in physics engines to model contact and friction constraints. The solution must satisfy conditions that forces are non-penetrating and non-adhesive. Warm starting is a critical optimization when solving the LCP iteratively.

• Formulation: Models the complementarity condition: 0 ≤ λ ⊥ a(x) + b ≥ 0, where λ is the impulse (the solution).
• Application: The LCP elegantly encodes that a contact impulse must be zero if bodies are separating (no penetration) and positive only if they are in contact. The solver's previous λ is the warm start value.

Baumgarte stabilization is a constraint stabilization technique that adds a corrective force proportional to both the constraint violation error and its derivative (velocity) to dampen numerical drift in constrained dynamical systems. It works in tandem with warm starting.

• Drift Correction: Without stabilization, small integration errors cause constraints (e.g., a joint) to slowly fall apart. Baumgarte applies a restoring force.
• Interaction with Warm Starting: The stabilized constraint forces from the previous time step provide a physically meaningful initial guess for the solver, making warm starting more effective than using a zero vector.

Impulse-based dynamics is a simulation method that resolves collisions and constraints by applying instantaneous changes in velocity (impulses) rather than continuous forces. Warm starting is inherently designed for this impulse-based solving approach.

• Impulse Accumulation: Solvers iteratively apply impulses to satisfy constraints. The total impulse from the last frame is an excellent predictor for the current frame.
• Real-time Use: Common in interactive applications (games, VR) where solver iteration counts are strictly budgeted. Warm starting is essential for maintaining stability within these limits.

Constraint drift is the numerical accumulation of error over time in a simulated constrained system, causing bodies to gradually penetrate or joints to separate from their intended positions. Effective warm starting helps mitigate the symptoms of drift by promoting solver convergence.

• Cause: Integration error and solver tolerance can leave small residual constraint violations.
• Warm Start's Role: By starting the solver close to the valid solution space, it can use its limited iterations to correct new forces and minor drift simultaneously, rather than starting from scratch each frame.

Convergence refers to the iterative solver's approach toward a solution that satisfies all physical constraints. Warm starting is the primary technique for improving convergence rate and quality in real-time simulations.

• Initial Guess: The quality of the initial guess (x₀) is paramount for iterative methods. A zero vector is a poor guess for continuous physical motion.
• Performance Impact: Good warm starting can reduce iteration counts by 30-70%, directly translating to lower computational cost per simulation step or higher fidelity within a fixed compute budget.