Iterated Racing (IR) Algorithms

• Iterated Racing (IR) is a data-driven control framework that iteratively refines trajectory planning using historic lap information for time-optimality and safety.
• The method leverages parallel local planning with iLQR and spatial ILC techniques to solve multiple short-horizon optimal control problems simultaneously.
• Empirical results demonstrate significant improvements in lap times and overtaking success for both vehicle and drone racing, ensuring real-time, collision-free performance.

Iterated Racing (IR) is a class of algorithms for time-optimal trajectory generation in autonomous racing environments that leverage iterative learning from previous laps to synthesize short-horizon, collision-free trajectories. In IR, the control strategy unifies lap-time minimization and obstacle avoidance using past experience, frequently employing iterative optimal control techniques such as i2LQR or spatial Iterative Learning Control (ILC). These approaches systematically update the racing vehicle's strategy at each time step in light of historic performance data, enabling rapid adaptation to dynamic environments and real-time computation suitable for multi-agent competitive racing scenarios (Zeng et al., 13 Jul 2025, Lv et al., 2023).

1. Formal Problem Statement

IR addresses the problem of synthesizing a time-optimal and safe trajectory for an agent (land vehicle or aerial drone) on a closed or partially closed course populated by static or dynamic obstacles. At each iteration or lap, the agent's state is updated, and the control law generates a local plan by optimizing a cost functional under dynamic, environmental, and safety constraints.

For ground vehicles, the state at time $t$ is $$x_t \in \mathbb{R}^6 = [v_x, v_y, \omega_z, e_\psi, s_c, e_y]^T$$, with control input $u_t \in \mathbb{R}^2 = [a, \delta]^T$, corresponding to the Frenet frame bicycle model. The discrete dynamics are linearized as: $$x_{t+k+1|t} = A_{t+k|t}\, x_{t+k|t} + B_{t+k|t}\, u_{t+k|t} + C_{t+k|t}$$ with a prediction horizon $N$ (e.g., $N=12$). Candidate terminal states $\{z_g\}_{g=1}^K$ are selected as $K$ nearest neighbors from the historized lap data, using a weighted norm for similarity. Each candidate yields a separate short-horizon optimal control problem, minimizing: $$J^{(g)} = (x_{t+N|t} - z_g)^T Q_N (x_{t+N|t} - z_g) + \sum_{k=0}^{N-1}\|u_{t+k|t}\|_R^2 + \sum_{k=1}^{N-1}\|u_{t+k|t} - u_{t+k-1|t}\|_{dR}^2 + \sum_{k=0}^{N-1}\sum_{p\in \text{obstacles}} c_{\mathrm{obs}}(x_{t+k|t}, x_{p,t+k|t})$$ subject to state, input, and collision-avoidance constraints.

For spatial ILC in drone racing, the state comprises position $p(l)$ and velocity $v(l)$ parameterized by spatial coordinate $l$ along the path. The total time is given by $T = \int_0^L (1/v(l)) dl$, and the objective is to minimize $T$ via the velocity control law $v_c(l)$ using a tube constraint $p(l)\in T_V$.

2. Core Algorithmic Principles

Both IR for vehicle and drone racing adopts an iterative, data-driven paradigm:

1. Historic Lap Utilization: At each iteration, a memory bank holds all previous $(x,u)$ pairs and associated cost-to-go values (remaining lap time). Terminal state candidates for planning are drawn from the $K$ nearest historic states with minimal cost-to-go.
2. Parallelized Local Planning: For each candidate, a short-horizon optimal control problem (quadratic or otherwise) is solved in parallel ($K=32$), yielding multiple control proposals.
3. Iterative Control Law Update: Central to spatial ILC implementations, the control law is updated after each lap based on path error and its spatial gradient, mimicking the iterative improvement process of skilled human racers.
4. Adaptive Collision Avoidance: Collision penalties are enforced using exponential barrier functions applied to ellipse-based pairwise safety conditions. If post-solution constraints are violated, barrier coefficients are increased, or trajectory tracking weights are softened, and the problem is re-solved.

A high-level schematic for IR-based ground vehicle planning is summarized as follows:

Step	Key Operation	Output
State Update	Extract $x_t$; retrieve $K$ nearest $z_g$ from history	candidate terminal states
Parallel Plan	Solve $K$ iLQR problems with individual $z_g$, including soft constraints	$K$ candidate trajectories
Collision Check	Evaluate candidate for collision/safety violations; adapt penalties	collision-free trajectory
Control Apply	Select optimal solution; apply first input to plant	actuator command

3. Implementation and Computational Complexity

IR leverages the structure of the iLQR algorithm for fast, local optimization with dynamic linearization and quadratic cost approximation. Each backward–forward pass has complexity $O(N n^3 + N m^3)$ per candidate, where $n$ is state dimension and $m$ is input dimension. Practical parameters ($n=6, m=2, N=12$) yield low per-solve cost. Parallelization (e.g., vectorized CasADi with IPOPT) across $K=32$ candidates enables operation at rates exceeding $33$ Hz on standard multi-core CPUs.

Soft-constraint violations are addressed by local penalty weighting adjustments and typically require only $1$–$2$ additional backward–forward passes per step. Average computation per time step is approximately $30$ ms, supporting real-time control.

Drone racing IR (spatial ILC) implementation is model-free: it requires no prior knowledge of system parameter $\tau$ or full dynamics. Each lap, velocity profiles $v^*_k(l)$ are iteratively refined using PD-style learning updates driven by local path error and its spatial derivative, with a bounded “activation” function balancing safety vs. aggressiveness in speed adaptation.

4. Collision Avoidance and Safety Enforcement

In IR, safety is ensured via two-stage restrictions:

• Soft Constraints: The exponential barrier penalty,

$$c_{\mathrm{obs}}(x, x_p) = q_1 \exp(q_2 f_{p,k}), \quad f_{p,k} = 1-(x-x_p)^T P_{t+k|t}(x-x_p)$$

penalizes elliptical-shaped pairwise proximity violations (with $P$ set from vehicle geometry, speed, and margin). These are interiorized to the optimal control problem.

• Explicit Hard Checks: After trajectory optimization, final collision-free conditions are checked explicitly: if violated,

$$\|(s_c - s_{c,p}, e_y - e_{y,p})\|^2 > \ell^2 + d^2,$$

the penalty weights are increased and the trajectory recomputed. This iterative weighting is essential for handling the variety of multi-vehicle interactions encountered in racing environments.

Moving obstacles (other cars) are assumed to provide open-loop predicted trajectories, typically following known feedback (PID) curves, with no interactive planning assumptions.

5. Empirical Performance and Comparisons

Extensive simulation and real-world experiments validate IR's efficacy for multi-agent racing.

For vehicle racing (Zeng et al., 13 Jul 2025):

• In high-fidelity simulation, IR achieves superior overtaking success rate (up to $62\%$) compared to LMPC-based baselines (near $0\%$), with smoother, collision-free overtakes.
• Average computation time per step is approximately $0.036$ s, significantly below baseline methods ($0.3$–$0.5$ s).
• Overtaking maneuvers remain time-optimal with respect to historic lap records, leveraging candidate terminal states with known remaining lap time for implicit learning.

For drone racing (Lv et al., 2023):

• On benchmark tracks, spatial ILC achieves lap times within $1.8\%$ of SQP-based true optima, while requiring orders of magnitude less training time (e.g., $110$–$150$ s vs. $1.3 \times 10^4$–$2.1 \times 10^4$ s).
• Against state-of-the-art baselines (HJB, HJB-RL, MOS, SL), IR consistently finds shortest lap time (e.g., minimum $24.02$ s, average $24.32$ s) and fastest convergence to optimal speed profiles.
• Real-world quadcopter experiments demonstrate rapid learning: lap time reduced from $50.35$ s to $20.19$ s within seven ILC iterations, with total online training $178.7$ s.

Algorithm	Best Time (s)	Average Time (s)
HJB-RL (best)	28.99	30.36
SL	30.13	36.14
Spatial ILC	24.02	24.32

This suggests IR's iterative-historical planning principle may remain effective across diverse dynamic domains with complex safety constraints.

6. Theoretical Properties and Convergence

For spatial ILC implementations, under mild assumptions on the system and boundedness of the "activation" learning function, the velocity profile sequence $v^*_{k}(l)$ remains uniformly ultimately bounded as $k\to\infty$. Local arc analysis confirms that, once converged, the system satisfies the Pontryagin maximum principle and thus achieves time-optimality on straight and curved segments. Numerical studies show final lap times within $0.2\%$ of the theoretical optima for realistic curvature.

Vehicle IR schemes inherit convergence from the iLQR method, under standard assumptions about controllability, and the inclusion of warm-start and terminal-state selection from historic cost-to-go implicitly encodes lifelong learning of optimal racing strategies.

7. Significance and Broader Impact

IR unifies time-optimality and safety in a real-time, data-driven iterative framework. Its adoption of parallel local trajectory optimization, history-based terminal state selection, and adaptive safety penalties distinguishes it from receding horizon and reinforcement learning approaches, providing:

• Real-time execution capability in multi-agent, competitive environments.
• Empirical superiority in lap time and overtaking metrics across a range of dynamic scenarios.
• Minimal reliance on explicit global modeling or parameter identification (model-free in drone racing), facilitating generalization.

A plausible implication is that IR’s iterative, experience-harnessing paradigm can serve as a foundational template for embedded, safety-critical real-time planning and control in future autonomous mobility domains, wherever time-optimality and adaptivity are essential.