Stanford Online
Differential flatness allows autonomous vehicles to bypass differential equation integration by algebraically reconstructing full system states and control inputs from smooth curves planned in a lower-dimensional output space.
AI-assisted summary of Stanford AA274A Principles of Robotic Autonomy | Autumn 2019 | Trajectory Optimization — original source. Check the original for full context.
Source published:
Key ideas
- Differential flatness eliminates the need to integrate non-linear differential equations during planning by establishing an algebraic mapping between system states, control inputs, and a reduced coordinate space of flat outputs. (54:07)
- Autonomous robotics circumvents the prohibitive computational cost of full-state closed-loop optimal control by utilizing a two-step architecture: generating an open-loop nominal reference trajectory and stabilizing it locally with a feedback tracking controller. (30:08)
- Numerical open-loop trajectory optimization is split into direct methods, which discretize continuous dynamics into finite-dimensional nonlinear programs, and indirect methods, which derive variational boundary-value differential equations before discretization. (33:33)
- Minimizing higher-order derivatives like jerk and snap provides a computationally efficient proxy for reducing actuator effort, serving as the design standard for roughly 95% of quadrotor trajectory planning algorithms. (66:25)
Detailed notes
## Background Published on YouTube by Stanford Online on October 9, 2026, this video documents Lecture 3 of the Autumn 2019 Stanford course AA274A (Principles of Robotic Autonomy), presented by Prof. Marco Pavone. According to the description, the session focuses on trajectory optimization, open-loop motion control, and differential flatness, providing theoretical foundations supported by the free companion textbook Principles of Robot Autonomy.
## TL;DR Prof. Marco Pavone formulates the trajectory optimization problem for autonomous robots, distinguishing between computationally intensive closed-loop policies and practical two-step architectures that pair open-loop nominal references with local feedback tracking. After contrasting direct discretization approaches with indirect variational methods, the lecture pivots to differential flatness as an efficient method for generating dynamically feasible paths without numerical integration. Using the kinematic simple car model, Pavone demonstrates how planning smooth polynomial curves in flat output coordinates allows full vehicle states and control inputs to be recovered algebraically. He concludes by detailing objective criteria such as minimum-snap optimization and explaining how actuator limits are handled via time scaling.
## Atmosphere & style The lecture carries an engaging, approachable academic atmosphere driven by Prof. Pavone's conversational teaching style and clear enthusiasm for robotics engineering. Theoretical derivations of differential equations and flatness mappings are regularly interspersed with spontaneous classroom demonstrations, student interactions, and lighthearted humor regarding childhood tricycles and dead-reckoning navigation. Watching the session feels like attending a rigorous yet demystifying graduate engineering workshop where complex mathematical abstractions are systematically translated into pragmatic, implementable autonomy algorithms.
## Bulletin - [54:07](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3247s) Differential flatness eliminates the need to integrate non-linear differential equations during planning by establishing an algebraic mapping between system states, control inputs, and a reduced coordinate space of flat outputs. - [30:08](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1808s) Autonomous robotics circumvents the prohibitive computational cost of full-state closed-loop optimal control by utilizing a two-step architecture: generating an open-loop nominal reference trajectory and stabilizing it locally with a feedback tracking controller. - [33:33](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2013s) Numerical open-loop trajectory optimization is split into direct methods, which discretize continuous dynamics into finite-dimensional nonlinear programs, and indirect methods, which derive variational boundary-value differential equations before discretization. - [01:06:25](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3985s) Minimizing higher-order derivatives like jerk and snap provides a computationally efficient proxy for reducing actuator effort, serving as the design standard for roughly 95% of quadrotor trajectory planning algorithms.
## Key takeaways - [01:01](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=61s) Trajectory optimization computes a continuous time history of states and control inputs that steers a robot between boundary conditions while honoring physical and kinematic constraints. - [06:50](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=410s) Forward Euler discretization models continuous differential equations into discrete updates, presenting a core robotic trade-off between numerical fidelity and computational runtime. - [16:37](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=997s) Optimal control cost functions rely on an additive structure combining terminal penalties and integrated running costs to ensure mathematical tractability under dynamic programming principles. - [21:44](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1304s) Trajectory optimization formally addresses dynamic feasibility in unconstrained state space, whereas motion planning addresses the non-convex complexity of explicit state constraints such as obstacle avoidance. - [24:56](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1496s) Open-loop control profiles match closed-loop policies in deterministic theory, but real-world unmodeled dynamics and disturbances inevitably cause uncorrected open-loop systems to drift. - [30:08](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1808s) Practical autonomy applies a two-step compromise that executes an open-loop nominal path while restricting feedback control effort to a local operating tube around the reference. - [34:40](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2080s) Direct methods convert continuous optimal control into solvable nonlinear programs via Riemann summation and Euler integration constraints. - [37:46](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2266s) Indirect methods apply the calculus of variations to derive first-order necessary conditions of optimality, formulating differential boundary value problems that require numerical solution. - [43:20](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2600s) Fast replenishment rates of 1 to 10 Hz in dynamic environments make discovering kinematically feasible trajectories far more practical than solving exhaustive optimal control problems. - [50:00](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3000s) In a kinematic simple car, rear axle coordinates completely determine vehicle heading and input commands algebraically, avoiding differential equation integration. - [54:07](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3247s) A system is differentially flat when there exist flat outputs equal in number to system inputs that algebraically reconstruct all states and inputs using finite time derivatives. - [59:07](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3547s) Trajectory generation for flat systems follows a three-step pipeline: mapping boundary conditions, interpolating a smooth curve in flat output space, and algebraically evaluating states and controls. - [01:02:15](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3735s) Representing flat outputs through polynomial basis functions reduces continuous path planning to linear constraint satisfaction or low-dimensional coefficient optimization. - [01:06:25](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3985s) Penalizing higher-order time derivatives—such as acceleration, jerk, and snap—smooths trajectory geometry and minimizes aggressive actuator saturation. - [01:09:32](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=4172s) Time scaling decouples geometric path synthesis from actuator limits by reparameterizing time along a flat trajectory until control bounds are satisfied. - [01:10:45](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=4245s) Control theory lacks a constructive computational procedure to test whether an arbitrary nonlinear dynamical system is differentially flat.
## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=6s) Course Logistics and the Role of ROS in Discussion Sections
Professor Marco Pavone opens the lecture by recapping the foundational ground covered during the first week. The opening lecture established the kinematic and dynamic models of robot motion, followed by an introductory orientation to the Robot Operating System (ROS). Moving forward, students will gain significantly deeper exposure to ROS during their weekly discussion sections. In the current week, students will set up the requisite software environments and development toolchains on their machines, while the following week's sections will guide them through building and executing their first live ROS nodes.
Pavone highlights the instructional philosophy behind this structure: the bulk of hands-on software engineering and coding activities are intentionally delegated to discussion sections. The teaching team found this interactive approach to be "a particularly effective way to teach you how to do things by having you doing things while having a CA watching you." This direct supervision from Course Assistants ensures that practical tooling hurdles and debugging issues are addressed immediately in an active lab setting rather than becoming roadblocks during assignments.
[01:01](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=61s) Defining the Trajectory Optimization Problem
Transitioning from system modeling to planning, the lecture pivots to leveraging kinematic and dynamic equations to generate robotic motion. Pavone frames the core challenge of the week as the trajectory optimization problem: given a robot's known initial state—such as its starting Cartesian coordinates and heading angle—and a desired destination state with a target position and heading, how can an algorithm compute an admissible trajectory that connects the two? In this context, a trajectory is formally defined as a time history of system states (positions, orientations, and velocities) spanning from the start time to the finish.
Crucially, the computed trajectory must respect all underlying physical and operational constraints governing the platform. For a wheeled ground vehicle, this means adhering strictly to non-holonomic kinematic restrictions, such as the pure rolling and no-slip conditions derived in the prior lecture. Beyond mere feasibility, however, autonomous systems must often optimize a defined performance criterion. Common objectives include arriving at the final state in minimum time, navigating with minimum control effort (energy expenditure), or balancing a multi-objective trade-off between the two.
```mermaid flowchart TD accTitle: Trajectory Optimization Problem Setup accDescr: Mapping initial robot state to final desired state through a constraint-compliant optimal path.
subgraph Inputs ["Problem Boundary Conditions"] Init["Initial Condition<br/>(Position x0, y0, Heading θ0)"] Goal["Target Condition<br/>(Position xf, yf, Heading θf)"] end
subgraph Engine ["Trajectory Optimization Engine"] Feas{"System Feasibility<br/>(Kinematics & No-Slip Constraints)"} Cost["Cost Function Minimization<br/>(Min Time, Min Control Effort)"] end
subgraph Output ["Result"] Traj["Optimal State Trajectory<br/>(Full Time History of States x(t))"] end
Init --> Feas Goal --> Feas Feas --> Cost Cost --> Traj ```
[02:30](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=150s) Course Readings and Reference Materials
Pavone details the standard organizational roadmap used across lectures: an introduction of the core topic, an explicit summary of learning objectives, and recommended background readings. He reiterates that AA274A does not mandate a required textbook; instead, the syllabus provides a curated list of recommended references.
For the trajectory optimization lectures, the primary reference text is *Robotics: Modelling, Planning and Control* by Bruno Siciliano, Lorenzo Sciavicco, Luigi Villani, and Giuseppe Oriolo, with the relevant foundational theory residing in Chapter 11. Pavone reassures the room that the lecture slides and provided lecture notes are fully self-contained. Students are solely responsible on exams for concepts explicitly presented during lectures and within the official course notes, meaning deeper deep-dives into external textbook chapters remain strictly optional.
[03:42](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=222s) Lecture Goals: Trajectory Methodologies and Differential Flatness
The roadmap for the session is twofold. Pavone's first objective is to supply a comprehensive theoretical overview of the various mathematical formulations used to solve trajectory optimization across modern robotics. Because trajectory optimization is one of the most fundamental algorithmic challenges in autonomous systems, understanding the breadth of solution paradigms is vital.
The second, primary focus is a deep dive into an analytical framework known as *differential flatness*. Pavone emphasizes that differential flatness is not a universal solver that applies blindly to every dynamical system; rather, it is a mathematically "clever method" applicable to a broad, highly practical class of non-linear robotic platforms. Most notably, multirotors, quadrotors, and various non-holonomic wheeled robots can be mapped cleanly through the lens of differential flatness. The technique is heavily stressed because of its prevalence in real-world aerospace and robotic autonomy pipelines.
- Differential flatness will be explored extensively throughout the lecture and exercised directly in Problem Set 1 (specifically Problems 1 and 3). - The mathematical machinery derived in this class will serve as the algorithmic backbone for the trajectory generation modules students must implement in their final course project.
[05:02](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=302s) Mathematical Foundations: Differential Equations in Robotics
Before diving into optimization mechanics, Pavone addresses common student concerns raised on Piazza regarding the mathematical prerequisites needed for handling differential equations. He reassures the class that advanced analytical integration techniques are entirely unnecessary for the course, and that all required concepts can be distilled onto a single slide.
In robotics, equations of motion are expressed as ordinary differential equations (ODEs) that relate the derivative of an unknown state function to the state function itself, alongside time-dependent parameters. The physical significance of an ODE lies in its solution: integrating the equation yields the complete time history of a robot's motion. Pavone notes that students will not be asked to derive closed-form symbolic solutions by hand. Instead, robotic autonomy relies on numerical integration schemes implemented through temporal discretization.
[06:50](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=410s) Numerical Discretization and Euler's Method
To demonstrate how continuous equations of motion are rendered computationally tractable, Pavone introduces numerical discretization via the forward Euler method. Grounded in the basic limit definition of a time derivative, $\dot{x}(t)$ is approximated over a finite time step $\Delta t$:
$$\dot{x}(t) \approx \frac{x(t + \Delta t) - x(t)}{\Delta t}$$
Replacing the approximation with a discrete equality allows the system state at the subsequent time increment to be predicted using forward difference:
$$x(t + \Delta t) = x(t) + \Delta t \cdot \dot{x}(t)$$
Starting from a known initial condition $x(t_0)$ at $t_0$, this formulation provides a recursive algorithm to compute the system trajectory across a discrete sequence of time points ($t_1 = t_0 + \Delta t$, $t_2 = t_1 + \Delta t$, and so forth). Pavone highlights that the time increment $\Delta t$ (often written as $h$ or $h_i$) embodies a fundamental engineering compromise: selecting an extremely small $\Delta t$ enhances trajectory fidelity at the cost of requiring vastly more integration steps and computing cycles, whereas choosing a large step size accelerates runtime while introducing substantial numerical inaccuracies.
Beyond the numerical mechanics, Pavone stresses the physical intuition: knowing the state derivative at an instantaneous point in time captures precisely "what the system is going to do next" given its current state. When an audience member asks whether the Euler method is chosen primarily for simplicity over higher-order alternatives, Pavone confirms that while numerous advanced discretization schemes exist, Euler integration represents the most intuitive and computationally transparent foundation for understanding how digital controllers interact with continuous physical dynamics.
```mermaid flowchart LR accTitle: Forward Euler Discrete Integration Cycle accDescr: Recursive state propagation cycle using discrete time steps.
InitState["Current State<br/>x(t) at time t"] --> EvalDeriv["Compute Derivative<br/>x_dot(t) from Dynamics"] EvalDeriv --> Step["Scale by Step Size<br/>Δt * x_dot(t)"] Step --> Update["Update State<br/>x(t + Δt) = x(t) + Δt * x_dot(t)"] Update -->|"Next Step (t ← t + Δt)"| InitState ```
[12:30](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=750s) Numerical Integration Trade-Offs: Accuracy vs. Computation
The discussion opens with a clarification on notation, equating the step size with the time increment $\Delta t$. When performing numerical forward integration from an initial time to a final time $t_f$ (for instance, integrating between $0$ and $1$), choosing a step size of $\Delta t = 0.1$ requires applying the update equation $10$ times. Shrinking the increment down to $\Delta t = 0.01$ yields a much more accurate approximation because the discretization is finer, but it demands $100$ iterations. In robotics, this introduces a fundamental, ubiquitous trade-off between accuracy/optimality on one hand and computation time on the other. As Marco Pavone emphasizes, "the art of being a roboticist is to have a good judgment call" when balancing these conflicting priorities.
A student asks whether the course will exclusively rely on computational numerical methods rather than analytical approaches. Pavone confirms that the curriculum is deliberately computational. Robotic systems are typically governed by nonlinear, high-dimensional differential equations that rarely admit closed-form analytical solutions, leaving numerical simulation and optimization as the only practical route forward.
[13:54](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=834s) Problem Formulation: Feasibility and System Constraints
Returning to the broader topic of trajectory optimization, Pavone frames the core challenge: using a mathematical model of a robot's equations of motion (represented as differential equations), how do we construct a state trajectory $x(t)$ that steers the vehicle from an initial condition at $t_0$ to a terminal condition at $t_f$? A trajectory here specifically refers to the full continuous time history of the state over the interval $[t_0, t_f]$. Crucially, this trajectory must satisfy several classes of physical system constraints simultaneously:
- **Kinematics and Dynamics:** The trajectory must obey the system's differential equations $\dot{x}(t) = f(x(t), u(t), t)$. - **Control Input Constraints ($u \in \mathcal{U}$):** The actuators have hard physical boundaries, such as velocity or acceleration limits. For a unicycle robot whose inputs are linear speed and angular speed, the linear speed might be capped below $10\text{ m/s}$, and the angular speed bounded within specific radians-per-second limits. - **State Constraints ($x \in \mathcal{X}$):** These typically correspond to obstacle avoidance. The robot's state must never intersect forbidden regions for any time $t$—meaning, as Pavone illustrates pointing to furniture in the lecture hall, "as I move I should never... intersect say this table."
If an engineer identifies a state history $x(t)$ and control history $u(t)$ that merely satisfy the equations of motion alongside the input and state bounds, they have found a *feasible trajectory*. If they go one step further and search across all possible feasible trajectories to find the one that minimizes a specific cost function, they are solving an *optimal trajectory control problem*.
```mermaid flowchart TD accTitle: Trajectory Optimization Classification accDescr: Flowchart illustrating feasibility criteria leading to feasible or optimal trajectory control problems. subgraph Inputs["System Specifications"] DE["Differential Equations<br>Kinematics & Dynamics"] UC["Control Bounds U<br>e.g., Velocity & Accel Limits"] XC["State Constraints X<br>e.g., Obstacle Avoidance"] end
subgraph Outcomes["Trajectory Types"] FT["Feasible Trajectory<br>Satisfies all constraints"] OT["Optimal Trajectory<br>Minimizes Cost Function J"] end
DE --> FT UC --> FT XC --> FT FT -->|"Add Cost Objective & Minimize"| OT ```
[16:37](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=997s) Anatomy of the Cost Function: Running and Terminal Costs
Pavone breaks down the mathematical structure of the objective cost function $J$, which is partitioned into a terminal penalty and an integrated running penalty:
$$J = h(x(t_f), t_f) + \int_{t_0}^{t_f} g(x(t), u(t), t) \, dt$$
The integral term represents the *running cost*, which accumulates continuously as the robot moves along its path. Because an integral is simply the continuous analog of a summation, the running cost reflects cumulative quantities. For example, if $g(x, u, t) = 1$, the integral accumulates elapsed time, formulating a minimum-time problem. If an additional control term such as $u(t)^2$ is added, the integral tracks control effort or energy consumption, since quadratic terms physically correlate with power expenditure.
Pavone stresses the vital importance of this *additive structure*. While one could imagine exotic nonlinear functionals of the integral, almost all of optimal control relies strictly on this additive form because it is what makes problems computationally tractable. In dynamic programming and reinforcement learning, the cost is defined as an expected sum for this exact reason: additivity allows one to invoke Bellman's Principle of Optimality and derive recursive equations. Removing additivity causes standard computational algorithms to collapse.
The first term, $h(x(t_f), t_f)$, is the *terminal cost*, incurred based on where the robot ends up at the final time $t_f$. This term provides a flexible way to penalize deviation from a target without enforcing a rigid equality constraint. For instance, if arriving in the vicinity of a desired final state $x_{d}(t_f)$ is acceptable, one can define the terminal cost as a squared Euclidean norm:
$$h(x(t_f), t_f) = \|x(t_f) - x_d(t_f)\|^2$$
This penalizes landing far away from the goal while leaving the solver room to trade terminal error against running effort. In response to student questions regarding constraints and negative values on $h$, Pavone notes that beyond mild differentiability conditions on $g$ and $h$ and the additive structure, the formulation is broadly accommodating—reserving deeper analytical proofs for his spring course on optimal and learning-based control.
[21:44](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1304s) Trajectory Optimization vs. Motion Planning and Historical Roots
Terminology across the academic literature can be inconsistent, but Pavone provides a clear dividing line for the course: - **Trajectory Optimization:** Focuses on generating dynamically feasible, optimal trajectories when there are *no state constraints* (i.e., the state space is unconstrained Euclidean space without obstacles). This is the focus of the current week. - **Motion Planning (or Trajectory Optimization with Obstacles):** Incorporates explicit *state constraints* such as collision avoidance with obstacles, which introduces significant non-convex geometric complexity. This topic will be tackled the following week.
When asked how an engineer determines the relative weighting between running cost terms (such as time versus fuel) and terminal accuracy, Pavone smiles: "that's why we still need humans as part of the design loop." The weights represent engineering trade-offs reflecting desired operational behavior. In pure minimum-time tasks, a designer might set $h = 0$, $g = 1$, and enforce a hard terminal boundary condition $x(t_f) = x_{d}(t_f)$, whereas fuel-conserving missions assign higher weight to control effort.
Finally, Pavone addresses whether the horizon endpoints $t_0$ and $t_f$ are fixed or free. While initial time $t_0$ is generally fixed, the terminal time $t_f$ can be a free optimization variable, as is standard in minimum-time formulations. He places this in historical context: modern optimal control was spurred during the Cold War by the pressing military need to intercept intercontinental ballistic missiles in minimum time under strict propellant constraints. This race catalyzed two distinct mathematical schools of thought: - **The Soviet School:** Led by Lev Pontryagin, which produced Pontryagin's Minimum (or Maximum) Principle as an analytical and variational solution framework. - **The American School:** Led by Richard Bellman, which established dynamic programming and the Principle of Optimality.
[24:56](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1496s) Optimal Control Methodologies: Closed-Loop vs. Open-Loop Formulations
Dynamic programming serves as one of the primary solution approaches to optimal control problems. While deep theoretical connections link dynamic programming to calculus of variations and trajectory optimization, those connections lie beyond the scope of this course and are covered in Prof. Marco Pavone's advanced spring course. A standard reference recommended for this material is Donald E. Kirk's classic textbook (*Optimal Control Theory: An Introduction*).
```mermaid flowchart TD accTitle: Two-Step Trajectory Optimization Architecture accDescr: Flow diagram showing nominal reference generation combined with a local feedback controller to produce the total control command.
subgraph TrajectoryDesign["Two-Step Trajectory Optimization"] direction TB OpenLoop["Open-Loop Reference u_nom(t)"] --> Summer((+)) Tracking["Local Feedback Controller K(x - x_nom)"] --> Summer Summer --> TotalControl["Actual Control Input u(t)"] end ```
When formulating trajectory optimization, one solves for a control function $u(t)$ over time. Depending on the information structure, the problem falls into one of two paradigms: - **Closed-loop optimal control**: The control input is synthesized as a feedback policy $u(x, t)$ depending on both the current state $x$ and time $t$. The system actively measures its state, adjusting actions based on where it actually is. - **Open-loop trajectory optimization**: The control input $u(t)$ depends strictly on the initial condition $(t_0, x_0)$ and time $t$. The control profile is computed entirely in advance.
Under a purely deterministic mathematical formulation—where no disturbances, process noise, or random variables exist—an open-loop input and a closed-loop policy yield identical paths. Given an initial condition, forward simulation predicts the exact state 10 seconds into the future. However, in physical engineering, the famous aphorism holds: *"all models are wrong and some are useful."* Because mathematical abstractions omit physical real-world effects, an uncorrected system drifts away from its planned path.
Prof. Pavone illustrates the practical difference with an impromptu classroom demonstration: - To walk over to a student named Robin in **open loop**, he closes his eyes and walks based purely on dead reckoning and his internal "inertial measurement unit." Lacking feedback, he immediately drifts off target with no way to correct his path. - Opening his eyes represents **closed-loop control**: visual sensing continuously provides state feedback relative to the room, allowing instantaneous corrections whenever drift occurs.
---
[30:08](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1808s) The Practical Compromise: Two-Step Trajectory Optimization
Although closed-loop feedback provides robustness against real-world drift, computing an optimal closed-loop control law $u(x, t)$ across the entire state space is computationally prohibitive. Optimizing over functions of both continuous state and time requires solving difficult partial differential equations (such as the Hamilton-Jacobi-Bellman equation). In contrast, open-loop controls $u(t)$ depend only on time, making them far easier and faster to compute.
To achieve the computational efficiency of open-loop optimization alongside the disturbance-rejection capabilities of closed-loop control, practical robotics almost universally employs a **two-step trajectory optimization** architecture: 1. **Nominal Reference Generation (Open Loop)**: An optimal open-loop reference trajectory $x_{\text{nom}}(t)$ and reference control profile $u_{\text{nom}}(t)$ are generated offline or at a low update rate. 2. **Local Feedback Tracking**: A feedback tracking controller superimposes a corrective term onto the reference signal: $$u(t) = u_{\text{nom}}(t) + u_{\text{feedback}}(x(t), x_{\text{nom}}(t))$$ This tracking law drives the physical system back toward the nominal trajectory whenever external disturbances cause it to stray.
In response to a student question regarding why one compromises rather than computing full closed-loop control, Pavone clarifies the engineering trade-off: a local tracking controller only needs to stabilize the system within an operating "tube" (e.g., 2 meters) around the nominal trajectory. A robot walking across a room does not require an all-encompassing policy capable of handling being *"teleported back in Italy."* Limiting the controller's scope to a local tube dramatically simplifies computation while preserving practical robustness.
---
[33:33](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2013s) Direct vs. Indirect Trajectory Optimization Methods
When solving open-loop trajectory optimization problems, numerical approaches fall into two distinct philosophies:
| Methodology | Core Philosophy | Procedure | |:--- |:--- |:--- | | **Direct Methods** | "First discretize, then optimize" | Discretize state trajectories, controls, dynamics, and integral costs into finite-dimensional variables and constraints, converting the problem into a standard nonlinear program (NLP). | | **Indirect Methods** | "First optimize, then discretize" | Apply the calculus of variations (e.g., Pontryagin's Minimum Principle) to derive first-order necessary conditions for optimality (Euler-Lagrange equations, costates), and then numerically discretize the resulting two-point boundary value problem. |
```mermaid flowchart LR accTitle: Direct vs Indirect Methods accDescr: Comparison of workflow pipelines between direct and indirect optimization methods.
subgraph DirectApproach["Direct Methods"] direction LR D1["Continuous Optimal Control Problem"] -->|"Discretize"| D2["Finite-Dimensional NLP"] D2 -->|"Optimize"| D3["Numerical Solution"] end
subgraph IndirectApproach["Indirect Methods"] direction LR I1["Continuous Optimal Control Problem"] -->|"Optimize (Variational Conditions)"| I2["Boundary Value Problem"] I2 -->|"Discretize"| I3["Numerical Solution"] end ```
---
[34:40](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2080s) Formulating Direct Methods via Numerical Discretization
Direct methods proceed by converting continuous-time trajectory optimization into finite-dimensional optimization. In its basic form, the continuous time horizon $[t_0, t_f]$ is partitioned into discrete intervals $t_i$ with step sizes $h_i = \Delta t = t_{i+1} - t_i$.
The continuous running cost is approximated using Riemann summation: $$\int_{t_0}^{t_f} g(x(t), u(t), t) \, dt = \sum_{i} \int_{t_i}^{t_i + \Delta t} g(x(t), u(t), t) \, dt \approx \sum_{i} g(x_i, u_i, t_i) \, h_i$$
Pavone reviews the basic single-variable calculus intuition: each small segment of the integral represents an area under the curve approximated by a rectangle with base width $\Delta t$ and height $g(t_i)$. As the interval $\Delta t$ shrinks, this approximation becomes increasingly accurate.
Similarly, continuous system dynamics $\dot{x}(t) = f(x(t), u(t), t)$ are discretized using forward Euler integration into equality constraints relating adjacent state steps: $$x_{i+1} = x_i + h_i f(x_i, u_i, t_i)$$
Through this transformation, the infinite-dimensional functional optimization problem becomes a finite-dimensional nonlinear programming problem, where the decision variables are the discrete sequence of states $x_i$ and control inputs $u_i$.
[037:46] Formulating Nonlinear Trajectory Optimization and Indirect Methods
Converting continuous trajectory optimization into a discrete nonlinear program (NLP) involves solving for the states $x_i$ and control inputs $u_i$ across all discretized time steps $i$, given the initial condition $x_0$. Because the dynamics function $g$ is generally nonlinear, this yields a constrained nonlinear optimization problem. While solving general NLPs is notoriously difficult, several specialized software packages exist for trajectory optimization.
A student asks about the terminal cost versus the running cost. The formulation shown simplifies the integral cost without the terminal cost for pedagogical ease, but a terminal cost term $h(x(t_f))$ can be appended directly without requiring numerical approximation. In response to questions about enforcing final state constraints (reaching a neighborhood or goal region) and handling free final time, dealing with these constraints is not straightforward; full treatments are reserved for an advanced spring course. The high-level split in optimal control methods is typically between direct methods (discretizing into an NLP) and indirect methods.
```mermaid flowchart TD accTitle: Direct vs Indirect Optimal Control Methods accDescr: Flowchart contrasting the direct parameterization path and the indirect necessary-conditions path in optimal control.
subgraph DirectApproach ["Direct Methods"] D1["Discretize States & Controls"] --> D2["Formulate Nonlinear Program (NLP)"] D2 --> D3["Solve via NLP Solver"] end
subgraph IndirectApproach ["Indirect Methods"] I1["Derive First-Order Necessary Conditions"] --> I2["Obtain Two-Point Boundary Value ODEs"] I2 --> I3["Discretize & Solve Boundary Value Problem"] end ```
The core philosophy of indirect methods mirrors standard unconstrained optimization: setting the gradient $\nabla f(x) = 0$ to find stationary candidate points. In optimal control, deriving first-order necessary conditions for optimality yields a system of differential equations (Euler-Lagrange or Pontryagin's Minimum Principle) rather than standard algebraic equations. Solving these boundary value differential equations requires discretization and specialized numerical techniques.
- In general unconstrained optimization, solving $\nabla f(x) = 0$ identifies candidate local extrema; in optimal control, necessary optimality conditions manifest as coupled differential equations. - In indirect approaches, you derive the necessary optimality conditions analytically first, then numerically solve the resulting differential equations for the optimal control trajectory.
---
[043:20] Moving from Optimality to Feasibility and Differential Flatness
In mobile robotics and wheeled systems, strictly optimizing an objective function is frequently unnecessary and computationally wasteful. In practice, finding a feasible trajectory—one that satisfies the differential equations of motion and actuator constraints while remaining well-behaved—is often sufficient. Autonomous robots operate in dynamic environments where obstacles move and context changes, making it imperative to recompute motion plans rapidly in a closed feedback loop at $1\text{ to }10\text{ Hz}$.
```mermaid flowchart LR accTitle: Differential Flatness Trajectory Generation Pipeline accDescr: Pipeline showing how flat output curve generation bypasses dynamic constraints before mapping back to full states and controls.
A["Pick Flat Outputs (e.g., x, y)"] --> B["Design Smooth Geometric Curve"] B --> C["Map Analytically to Full State (x, y, θ)"] C --> D["Map Analytically to Control Inputs (v, ϕ)"] ```
For a special class of systems known as *differentially flat systems*, computing a dynamically feasible trajectory becomes exceptionally straightforward and computationally fast. Rather than solving constrained differential equations directly, the problem reduces to generating a smooth geometric curve in a lower-dimensional output space and algebraically mapping it back to the vehicle's full states and inputs.
- Real-time robotic navigation demands control loop replenishment rates between $1\text{ Hz}$ and $10\text{ Hz}$. - Differential flatness bridges rigorous differential geometry and practical robotics by enabling constraint-free trajectory generation in a reduced coordinate space.
---
[045:10] Motivating Example: Kinematics of the Simple Car
To build intuition before defining the mathematical machinery, consider the kinematic model of a simple car. The system state consists of the position of the midpoint of the rear axle $(x, y)$ and the vehicle heading $\theta$. The control inputs are the forward speed $v$ of the rear axle midpoint and the front steering angle $\phi$.
Addressing a forum question from Piazza regarding whether $\phi$ can equal $\pi/2$: setting $\phi = \pi/2$ causes the front wheels to orient perpendicular to the rear wheels, mechanically jamming the vehicle. Pavone jokes about childhood toys: > "I think you are probably too old to play that vehicle and too young to have kids. That's a problem. It's a tricycle... you know the thing where you move the wheel from the front, right? So that is front-wheel actuated and in principle, if you're able to steer your legs, you can actually have an angle of 90 degrees with your rear wheels."
For standard rear-driven cars, the steering angle must remain strictly bounded: $|\phi| < \pi/2$.
Given initial states $(x_0, y_0, \theta_0)$ and final states $(x_f, y_f, \theta_f)$, the objective is to generate a feasible path under velocity and steering limits. If someone draws an arbitrary smooth geometric curve connecting just $(x_0, y_0)$ to $(x_f, y_f)$, an arbitrary nonlinear system cannot guarantee that a time history of controls $(v(t), \phi(t))$ exists to track it. However, because the simple car is differentially flat, the trajectory of the rear axle $(x(t), y(t))$ alone completely determines the heading $\theta(t)$ and the control inputs $v(t)$ and $\phi(t)$ algebraically and through differentiation, bypassing differential constraints during the planning phase.
- **Simple car state vector**: Rear axle midpoint position and orientation, $(x, y, \theta)$. - **Control inputs**: Forward linear velocity $v$ and front wheel steering angle $\phi$. - **Steering constraint**: $|\phi| < \pi/2$ to prevent singularity and physical binding. - **Differential flatness advantage**: Trajectory curves can be planned in the unconstrained 2D flat output space $(x(t), y(t))$ and directly mapped to full states and valid controls without integrating differential equations.
[50:00](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3000s) Reconstructing Heading and Control Inputs from Rear-Wheel Position
Starting from a specified smooth trajectory for the rear-wheel coordinates $(x(t), y(t))$ along with its time derivatives $(\dot{x}, \dot{y}, \ddot{x}, \ddot{y})$, the core question is how to determine the linear velocity $v(t)$ and steering angle $\phi(t)$ required to physically realize that motion. Examining the kinematic car's equations of motion, $\dot{x} = v \cos\theta$ and $\dot{y} = v \sin\theta$, dividing the two expressions immediately yields $\frac{\dot{y}}{\dot{x}} = \tan\theta$. This relationship directly fixes the orientation angle without requiring any differential equation solving:
$$\theta(t) = \arctan\left(\frac{\dot{y}(t)}{\dot{x}(t)}\right)$$
With the heading angle expressed purely as a function of the position derivatives, the velocity input $v(t)$ follows directly from the equations of motion as $v = \frac{\dot{x}}{\cos\theta}$. In cases where $\cos\theta = 0$, one simply uses the companion relation $v = \frac{\dot{y}}{\sin\theta}$; because sine and cosine cannot simultaneously vanish, a valid velocity can always be recovered. When a student asks whether velocity could instead be calculated as the norm $\sqrt{\dot{x}^2 + \dot{y}^2}$, Professor Pavone clarifies that taking the Euclidean norm yields an absolute magnitude and loses the sign, which is critical for determining forward versus reverse motion. While one could determine the sign through auxiliary conventions, the algebraic expression $v = \frac{\dot{x}}{\cos\theta}$ naturally preserves directionality. Furthermore, as Pavone highlights, "the mapping between the subset of variables that you use to define a curve geometrically and the set of inputs that realize that curve is not necessarily unique."
Turning to the front-wheel steering input $\phi(t)$, the kinematics dictate that $\dot{\theta} = \frac{v}{L} \tan\phi$, where $L$ is the wheelbase. Because $\theta$ is already known in terms of $\dot{x}$ and $\dot{y}$, differentiating that relationship with respect to time provides $\dot{\theta}$ as a function of $\dot{x}, \dot{y}, \ddot{x}$, and $\ddot{y}$. Rearranging the kinematic equation then yields the steering angle explicitly:
$$\phi(t) = \arctan\left(\frac{L}{v(t)} \dot{\theta}(t)\right)$$
- Heading angle recovery: $\theta = \arctan(\dot{y} / \dot{x})$ - Forward velocity recovery: $v = \dot{x} / \cos\theta$ (or $\dot{y} / \sin\theta$ if $\cos\theta = 0$) - Front steering angle recovery: $\phi = \arctan\left(\frac{L}{v} \dot{\theta}\right)$, where $\dot{\theta}$ is obtained by analytically differentiating $\arctan(\dot{y} / \dot{x})$ using second derivatives $\ddot{x}$ and $\ddot{y}$
[54:07](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3247s) Defining Differential Flatness and Flat Outputs
This derivation demonstrates that every remaining state variable and control input is completely determined by the trajectory of the rear wheels and its derivatives. In the terminology of differential flatness, this privileged subset of coordinates $z = [x, y]^T$ is designated as the **flat output**. The remaining state $\theta$ is recovered through an algebraic map $\beta(z, \dot{z})$, while the control vector $u = [v, \phi]^T$ is recovered through a map $\gamma(z, \dot{z}, \ddot{z})$. Because $\dot{\theta}$ depends on the acceleration components $\ddot{x}$ and $\ddot{y}$, evaluating $\phi$ naturally pulls in the second time derivative of the flat output.
A student inquires what general structural property enables a system to possess such a representation, prompting Pavone to promise an answer toward the end of the lecture while setting up the rigorous theoretical definition. Formally, a nonlinear control system is said to be differentially flat if there exists a vector of flat outputs $z$ that depends only on the states, the inputs, and possibly derivatives of the inputs—crucially without depending on derivatives of the state—such that all system states $x$ and control inputs $u$ can be expressed as functions of $z$ and a finite number of its time derivatives:
$$x = \alpha(z, \dot{z}, \ddot{z}, \dots), \quad u = \beta(z, \dot{z}, \ddot{z}, \dots)$$
Importantly, the number of flat outputs must precisely equal the number of independent control inputs. In the kinematic car model, there are two control inputs ($v$ and $\phi$) and two flat outputs ($x$ and $y$). The fundamental operational takeaway is that states and inputs can be reconstructed entirely through algebraic evaluation and differentiation, completely bypassing the need to integrate differential equations. The name "differentially flat" originates from the fact that the components of $z$ are differentially independent—meaning they are not bound to one another by any underlying differential equation.
[59:07](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3547s) The Three-Step Trajectory Optimization Algorithm
When asked what makes the simple car steering amenable to differential flatness, Pavone calls it the "million-dollar question" and notes that the technique can feel like magic. Because any sufficiently differentiable curve in the flat output space maps directly to feasible state and input trajectories via algebraic equations, one can plan and optimize curves entirely in the lower-dimensional flat output space without having to enforce dynamic differential constraints during the search.
This insight gives rise to a straightforward three-step algorithm for trajectory optimization, which forms the basis of Problem 1 in the course's first problem set:
```mermaid flowchart LR accTitle: Three-Step Trajectory Optimization Pipeline accDescr: Pipeline showing boundary mapping, curve interpolation in flat space, and algebraic recovery of states and inputs.
subgraph Step1["Step 1: Map Boundaries"] A["State & Input Boundaries<br/>x(t₀), u(t₀), x(t_f), u(t_f)"] --> B["Flat Output Boundaries<br/>z(t₀), ż(t₀), z(t_f), ż(t_f)"] end
subgraph Step2["Step 2: Plan Path"] B --> C["Interpolate Smooth Curve<br/>z(t) via Polynomials"] end
subgraph Step3["Step 3: Recover Control"] C --> D["Evaluate Algebraic Mappings<br/>x(t) = α(z, ż,...)<br/>u(t) = β(z, ż, z̈,...)"] end ```
- **Step 1: Map Boundary Conditions:** The initial and final specifications on states and control inputs are transformed into equivalent boundary conditions on the flat output $z$ and its derivatives at $t_0$ and $t_f$. - **Step 2: Smooth Interpolation:** A smooth trajectory $z(t)$ connecting those boundary conditions is generated in the flat output space. Pavone notes a minor typo on his slide (which labeled the flat output as $y$ rather than $z$) and explains that polynomial interpolation is the standard tool used in the course. - **Step 3: State and Control Recovery:** The maps $\alpha$ and $\beta$ (earlier referred to as $\beta$ and $\gamma$) are evaluated along $z(t)$ and its time derivatives to reconstruct the full time histories of all states and open-loop control inputs, guaranteeing kinematic feasibility by construction.
[01:02:15](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3735s) Polynomial Interpolation and Basis Functions
Polynomial interpolation makes computing nominal trajectories computationally lightweight and exceptionally reliable. Rather than risking a solver failure—where a trajectory optimizer crashes in real time with an unhelpful error like "none found"—polynomial interpolation provides a well-conditioned formulation that can comfortably execute at 100 Hz. When a student asks whether the specific interpolation curve chosen affects the resulting trajectory, Dr. Pavone confirms that it certainly does. While differential flatness fundamentally frames motion planning as a feasibility problem (connecting given initial and final conditions), practitioners often incorporate a notion of compromise optimality to select a high-quality curve.
To implement this, each flat output variable $z_j(t)$ is parameterized as a linear combination of chosen basis functions:
$$z_j(t) = \sum_i a_{ij} \psi_i(t)$$
For instance, selecting the canonical polynomial basis functions $\psi_1(t) = 1$, $\psi_2(t) = t$, $\psi_3(t) = t^2$, and $\psi_4(t) = t^3$ yields standard cubic interpolation. Rather than optimizing over an infinite-dimensional function space, the planner solves only for the finite set of unknown scalar coefficients $a_{ij}$. Introducing more basis functions expands the optimization search space and potentially yields smoother or higher-quality paths, but it incurs a greater computational cost. Despite alternatives, polynomial splines remain deeply favored across robotics because they avoid complex numbers, are mathematically transparent, and are straightforward to implement.
When a student inquires what happens if the number of basis functions exceeds the dimension of the boundary constraints, Dr. Pavone explains that the setup naturally transitions into an optimization problem: - Initial and terminal constraints on state $x$ and control $u$ are mapped into corresponding boundary constraints on the flat outputs $z$ and their derivatives. - Setting up matching equations produces a system of linear constraints on the interpolation coefficients $a_{ij}$. - If the system is underdetermined (more coefficients than constraint equations), the remaining degrees of freedom are selected by minimizing a secondary cost objective over the coefficients. - In the class problem set (pset), students use cubic polynomial interpolation on a dynamically extended unicycle model.
```mermaid flowchart LR accTitle: Trajectory Generation via Differential Flatness and Polynomial Interpolation accDescr: Pipeline showing how boundary conditions are converted to flat output constraints, solved via basis function coefficients, and mapped back to nominal state and control trajectories. subgraph Bounds["Boundary Constraints"] BC["Initial & Final<br/>States x and Inputs u"] FBC["Flat Output<br/>Boundary Conditions z(t)"] end subgraph Optimization["Parameterization & Solve"] Basis["Polynomial Basis<br/>Functions ψᵢ(t)"] Coeffs["Solve / Optimize<br/>Coefficients aᵢⱼ"] end subgraph Mapping["Flatness Reconstruction"] ZTraj["Nominal Output Trajectory<br/>z*(t)"] Nominal["Nominal State x*(t)<br/>& Control u*(t)"] end
BC --> FBC FBC --> Coeffs Basis --> Coeffs Coeffs --> ZTraj ZTraj --> Nominal ```
---
[01:06:25](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3985s) Beyond Feasibility: Minimizing Jerk, Snap, and Curvature
While matching kinematic boundary conditions establishes nominal motion, real robots operate under additional constraints and performance requirements. Translating generic state and input bounds directly into flat output coordinates can be analytically difficult. In practice, roboticists rely on proxies in the flat output space. Extreme geometric variations—such as abrupt changes in path curvature—directly require aggressive, high-effort control actions. Consequently, smoothing the geometry of the curve serves as an effective surrogate for conserving actuator effort.
Beyond basic feasibility, optimization objectives are routinely formulated over higher-order time derivatives of the flat output trajectory: - **First derivative ($\dot{z}$)**: Velocity - **Second derivative ($\ddot{z}$)**: Acceleration - **Third derivative ($z^{(3)}$)**: Jerk - **Fourth derivative ($z^{(4)}$)**: Snap - **Fifth derivative ($z^{(5)}$)**: Crackle (eliciting amused disbelief from the class: "You didn't know about that one?")
Minimizing snap or jerk suppresses erratic oscillations, yielding trajectories that require mild control inputs and execute smoothly. Dr. Pavone highlights that snap minimization is the "de facto standard" for autonomous aerial vehicles: roughly 95% of quadrotor trajectory planning algorithms seen in robotics demonstrations rely on minimum-snap formulations.
---
[01:09:32](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=4172s) Handling Input Bounds via Time Scaling
When hard input bounds must be enforced—such as restricting linear velocity to $u \le 5\text{ m/s}$—a dedicated technique called **time scaling** is used. Rather than solving a constrained, non-convex optimization problem from scratch, the pipeline first computes a geometric trajectory purely based on differential flatness without regard to actuator saturation:
- The initial trajectory fulfills differential flatness boundary conditions. - The path is subsequently time-reparameterized, slowing down or speeding up the progression of time along the curve until all input constraints are satisfied. - This time-scaling strategy forms the core of the first assignments in the upcoming problem set.
---
[01:10:45](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=4245s) Determining Differential Flatness and Literature References
Despite the immense utility of differential flatness, Dr. Pavone cautions that no general, computationally decidable algorithm exists to test whether an arbitrary nonlinear system is flat. While necessary and sufficient theoretical conditions exist in control theory, they rarely translate into constructive decision procedures. Finding a flat output mapping for a novel dynamical system remains a prized contribution worthy of a dedicated academic publication.
Key literature resources highlighted for further study include: - **Richard Murray (Caltech)**: Foundational papers exploring both the concrete implementation details of differential flatness in trajectory optimization and comprehensive survey papers cataloging known flat systems and their coordinate transformations ($h$ and $\gamma$). - **Wheeled mobile robot literature**: Reference texts covering flatness mappings specifically tailored to nonholonomic wheeled systems, matching the models investigated in AA274A.
[01:13:02](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=4382s) Literature on Differential Flatness and Preview of Trajectory Tracking
Professor Pavone wraps up the lecture by directing students toward literature for those interested in the deeper mathematical theory behind differential flatness. He highlights Chapter 11 of the course text as the primary place to look from a theoretical standpoint. Beyond that, he cites Jean Lévine's textbook as an excellent yet "extremely mathematically dense" reference, warning students with a smile to "read this book with caution." He also mentions a slightly less mathematically grueling alternative text for those wishing to dive into the rigorous necessary and sufficient conditions for differential flatness. However, he reassures the room that untangling these formal existence proofs is far beyond the scope of AA274A. For mobile robotics, the essential and fortunate takeaway is purely practical: both the unicycle model used for their course robot and the simple car model are differentially flat, allowing students to exploit flatness directly without worrying about the underlying mathematical edge cases.
Looking ahead to the next session, Pavone outlines how they will complete the trajectory generation and tracking framework. First, they will finish the discussion on differential flatness by addressing how to enforce constraints—specifically input constraints on velocity and actuation—using the technique of time scaling. From there, the lecture will pivot to the second half of the two-step architecture: transitioning from feedforward open-loop nominal trajectories to feedback trajectory tracking, designing closed-loop control laws that ensure the physical robot stays tightly bound to the planned path despite disturbances and modeling errors.
- **Theoretical References**: Chapter 11 provides the core theoretical foundation for the course, while texts such as Jean Lévine's offer deep mathematical explorations into the necessary and sufficient conditions of flatness. - **Core Mobile Robot Models**: Both the unicycle kinematic model and the simple car model possess differential flatness, making flatness-based trajectory generation directly applicable to ground autonomous systems. - **Next Steps in Motion Control**: - Incorporating actuator and input limits into flat trajectories via time scaling. - Designing closed-loop trajectory tracking control laws to stabilize the vehicle around the nominal trajectory.
## Notable quotes > [00:06](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=6s) a particularly effective way to teach you how to do things by having you doing things while having a CA watching you. — Prof. Marco Pavone
> [06:50](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=410s) what the system is going to do next — Prof. Marco Pavone
> [12:30](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=750s) the art of being a roboticist is to have a good judgment call — Prof. Marco Pavone
> [13:54](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=834s) as I move I should never... intersect say this table. — Prof. Marco Pavone
> [21:44](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1304s) that's why we still need humans as part of the design loop. — Prof. Marco Pavone
> [24:56](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1496s) all models are wrong and some are useful. — Prof. Marco Pavone
> [30:08](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=1808s) teleported back in Italy. — Prof. Marco Pavone
> [33:33](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2013s) First discretize, then optimize — Prof. Marco Pavone
> [33:33](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2013s) First optimize, then discretize — Prof. Marco Pavone
> [45:10](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=2710s) I think you are probably too old to play that vehicle and too young to have kids. That's a problem. It's a tricycle... you know the thing where you move the wheel from the front, right? So that is front-wheel actuated and in principle, if you're able to steer your legs, you can actually have an angle of 90 degrees with your rear wheels. — Prof. Marco Pavone
> [50:00](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3000s) the mapping between the subset of variables that you use to define a curve geometrically and the set of inputs that realize that curve is not necessarily unique. — Prof. Marco Pavone
> [59:07](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3547s) million-dollar question — Prof. Marco Pavone
> [01:02:15](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3735s) none found — Prof. Marco Pavone
> [01:06:25](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=3985s) You didn't know about that one? — Prof. Marco Pavone
> [01:13:02](https://www.youtube.com/watch?v=Kv5G2OlrIbU&t=4382s) read this book with caution. — Prof. Marco Pavone
## Mentioned Marco Pavone, Robot Operating System (ROS), Piazza, Bruno Siciliano, Lorenzo Sciavicco, Luigi Villani, Giuseppe Oriolo, Robotics: Modelling, Planning and Control, Leonhard Euler, Richard Bellman, Lev Pontryagin, Donald E. Kirk, Optimal Control Theory: An Introduction, Jean Lévine, Richard Murray, Caltech, Stanford University, NVIDIA, NASA Jet Propulsion Laboratory
## Video description For more information about Stanford’s graduate programs, visit: https://online.stanford.edu/graduate-education
Lecture 3 — Trajectory Optimization: Open-Loop Motion Control and Differential Flatness
Note: This lecture was recorded as part of the 2019 edition of the course. Course content, structure, assignments, and other materials may have changed since this recording. The course links below point to the most recent edition and may therefore differ from what is presented in the video.
Read the companion textbook, Principles of Robot Autonomy, free online: https://porabook.com
Follow along with the latest course schedule and syllabus: https://stanfordasl.github.io/PoRA-I
Speaker: Prof. Marco Pavone
Dr. Marco Pavone is an Associate Professor of Aeronautics and Astronautics at Stanford University and a Senior Director of Autonomous Vehicle Research at NVIDIA. Prior to joining Stanford, he was a Research Technologist in the Robotics Section at NASA’s Jet Propulsion Laboratory. Dr. Pavone received his Ph.D. in Aeronautics and Astronautics from the Massachusetts Institute of Technology in 2010. His research focuses on the analysis, design, and control of autonomous systems, with particular emphasis on self-driving cars, autonomous aerospace vehicles, and future mobility systems. He has been recognized with numerous awards, including the Presidential Early Career Award for Scientists and Engineers from President Barack Obama, the Office of Naval Research Young Investigator Award, the NSF CAREER Award, the NASA Early Career Faculty Award, the IEEE Kiyo Tomiyasu Award, the CSS Award for Technical Excellence in Aerospace Control, and the Early-Career Spotlight Award from the Robotics Science and Systems Foundation.
Full playlist: https://www.youtube.com/playlist?list=PLR9iNyexfIkk
#StanfordOnline #RobotAutonomy #Robotics #PhysicalAI
[Source](https://www.youtube.com/watch?v=Kv5G2OlrIbU)