Autonomous Robotics

1.1 · The state-space model — the robot as a step function

First region of the formula sheet; drilled by Ex 16–18 and both lab problems; the notation ẋ = f(x, u) reappears in every later module.

As a developer you already know this pattern. A state-space model is exactly a reducer:

state_next = f(state, control)     # motion model  ("what the robot does")
observation = h(state, control)    # sensor model  ("what the robot sees")

The state x is the minimal struct of numbers that makes the future independent of the past — position, heading, velocities. If you can predict tomorrow from today's x and the input u, nothing else needs storing. The control u is your input (wheel speeds, acceleration commands). The output y is what sensors expose — a view over the state, often lossy (a camera sees pixels, not your velocity).

Two flavors, both on your sheet:

• Continuous time: ẋ = f(x, u) — “ẋ” (x-dot) is the time-derivative: the instantaneous rate of change of the state. Think of it as the direction the state is drifting right now.
• Discrete time: x_k+1 = f_k(x_k, u_k) — the loop iteration you'd actually implement. Time advances in ticks of Δt.

Bridging the physics gap — the only two facts you need from mechanics: velocity is the rate of change of position (v = ẋ), and acceleration is the rate of change of velocity (a = v̇). Integrating a constant acceleration over a step Δt therefore gives:

The ½aΔt² term exists because velocity is changing during the step — position gains the average of old and new velocity, and that average is v_t + ½aΔt. not on sheet — memorize These two equations are demanded verbatim by Ex 16 and inverted by Ex 17.

Exercise 16 · Dynamic Robot Model

Exam working · ≈3 min (a) v̇ = a, a constant over Δt definition of acceleration  integrate over one step: v_t+1 = v_t + aΔt (b) ẋ = v, v changes linearly during the step so use average velocity  x_t+1 = x_t + v̄Δt, v̄ = v_t + ½aΔt  x_t+1 = x_t + v_tΔt + ½aΔt² (c) Position accumulates larger error — every velocity error is integrated  into position at each step; position error grows even if velocity error stays bounded.

Breakdown.

1. (a) is one sentence of calculus: if the rate of change of v is the constant a, then after Δt seconds v has grown by aΔt. In code: v += a*dt.
2. (b) is the same move applied to position, except the rate (velocity) is itself moving. Over the step it goes v_t → v_t+aΔt linearly, so the distance covered is the average velocity times Δt. Expanding (v_t + ½aΔt)Δt gives the boxed formula. If you ever forget the ½: it is the area of the triangle under a linearly-growing velocity curve.
3. (c) is the error-propagation insight the course reuses in Module 8: summing (integrating) noisy values makes the sum's error grow without bound. Velocity gets a fresh error each step; position gets the running total of them.

Deeper take. This tiny model is the seed of everything in localization: “dead reckoning drifts, so you need sensors” (Ex 18c) and “the Kalman prediction step increases uncertainty” (Ex 11a) are both restatements of part (c). Source: official Solution 16 agrees on all three parts.

Exercise 17 · Recovering Motion

Exam working · ≈2 min (a) Yes — one unknown (a), one equation (the position update). (b) x₁ = x₀ + v₀Δt + ½aΔt² from Ex 16(b)  ½aΔt² = x₁ − x₀ − v₀Δt  a = 2(x₁ − x₀ − v₀Δt) / Δt² (c) No — infinitely many a(t) profiles hit the same x₁; would need final  velocity or intermediate measurements to pin the profile down.

Breakdown.

1. Write the forward model first (green), then treat it as an equation in the one unknown you want. This “invert the motion model” move is the entire trick — the algebra is two lines.
2. For (c), think API contract: constant-a is a one-parameter family, so one end-point measurement identifies it. Arbitrary a(t) is an infinite-dimensional family — one scalar equation cannot identify a function. Any profile with the same time-average effect gives the same x₁.

Exercise 18 · Error Accumulation

Exam working · ≈2 min (concept answer) (a) Each estimate is built on the previous one: x_t+1 depends on x_t.  An error at step t is carried into every later step — errors compound. (b) Position — velocity errors get integrated into position (Ex 16c). (c) Dead reckoning has no correction term: drift grows without bound.  External sensors (camera, LiDAR, GPS, landmarks) provide absolute references that reset the drift.

Breakdown. One mental picture answers all three parts: open-loop state estimation is a chain of function calls where each call's output is the next call's input — error is data corruption propagating through a pipeline with no validation step. Sensors are the validation step; Module 8 turns this intuition into the Bayes filter's predict/correct loop.

1.2 · Trajectories and time scaling — the chain rule at work

Directly assessed by Ex 6; the chain-rule pattern returns in EKF Jacobians (Module 8).

A path is geometry: X(s) maps a progress parameter s ∈ [0,1] to a point in space — like a progress bar position mapping to a location. A time scaling s(t) says how fast the progress bar advances. Composing them gives the trajectory X(s(t)), and the chain rule differentiates a composition:

not on sheet — memorize the Ẍ pattern The Ẍ formula is product rule applied to Ẋ = X′(s)·ṡ: differentiate X′(s(t)) (gives X″·ṡ, times the outer ṡ → ṡ²) plus X′ times the derivative of ṡ (gives s̈). If you remember one check: the ṡ² and the single s̈ term.

Exercise 6 · Cylindrical Path

Exam working · ≈4 min X(s) = (cos 2πs, sin 2πs, 2s), s(t) = ¼t + ⅛t² ṡ = ¼ + ¼t = (1+t)/4, s̈ = ¼ differentiate s(t) twice dX/ds = (−2π sin 2πs, 2π cos 2πs, 2) d²X/ds² = (−4π² cos 2πs, −4π² sin 2πs, 0) Ẋ = (dX/ds)·ṡ chain rule  Ẋ = (−2π sin(2πs), 2π cos(2πs), 2) · (1+t)/4 Ẍ = (d²X/ds²)·ṡ² + (dX/ds)·s̈ product + chain rule  Ẍ = (−4π²cos(2πs), −4π²sin(2πs), 0)·((1+t)/4)² + (−2π sin(2πs), 2π cos(2πs), 2)·¼ with s = s(t) substituted in. ✓ check: at t=0, ṡ=¼ > 0 — motion starts forward

Breakdown.

1. Differentiate the scalar time scaling first — it is the easy part and both results need it. ṡ = ¼ + t/4, s̈ = ¼.
2. Differentiate the path component-wise with respect to s, not t. Each cos/sin pulls out a factor 2π (inner derivative of 2πs); z-component 2s just gives 2.
3. Assemble with the two green formulas. Do not multiply things out unless asked — the factored form is the official answer and faster to write.
4. Common trap: writing Ẍ = (d²X/ds²)·ṡ² and forgetting the (dX/ds)·s̈ term. Here s̈ = ¼ ≠ 0, so the second term is very much alive.

Deeper take. Why the course cares: separating path from timing is how planners work (Module 9) — one component finds a collision-free geometric path, another schedules speed along it (subject to velocity/acceleration limits). The chain rule is the interface between the two layers. Source: official Solution 6 agrees.

1.3 · Simulating dynamics — Euler, midpoint, RK4, odeint

Lab Problem 1 (150426); slides ch. 1 devote a worked figure to comparing the integrators; concept questions about integration error are cheap exam marks.

You cannot usually solve ẋ = f(x, u) symbolically, so you simulate. All integrators are variations of one loop — the difference is only how carefully they sample f during the step:

# Euler — one sample, first-order accurate: error per step ~ O(dt²)
x = x + dt * f(x, u)

# Midpoint — probe half a step ahead, use the slope there: O(dt³) per step
x_mid = x + 0.5*dt * f(x, u)
x     = x + dt * f(x_mid, u)

# RK4 — four slope samples, weighted average: O(dt⁵) per step
k1 = f(x);  k2 = f(x + dt/2*k1);  k3 = f(x + dt/2*k2);  k4 = f(x + dt*k3)
x  = x + dt/6 * (k1 + 2*k2 + 2*k3 + k4)

Euler is x += f(x)*dt — cheap, drifts on curved dynamics (it always follows the tangent from the step's start). RK4 samples the slope four times per step and averages; scipy.integrate.odeint goes further with adaptive step size. Trade-off is calls-to-f per step vs. allowed step size — exactly a precision/compute budget trade.

Lab Problem 1 · Numerical Integration Methods ▲ programming task — solution outline independently written (no official solution supplied)

The task is implementation: write each model as a function returning the state derivative, hand it to odeint.

def damped_pendulum(state, t, g=9.81, l=1.0, b=0.1, m=1.0):
    theta, omega = state                     # state = [angle, angular velocity]
    return [omega, -(g/l)*np.sin(theta) - (b/(m*l**2))*omega]

def bicycle(state, t, v=1.0, alpha=0.1, L=1.0):
    x, y, theta = state                      # pose
    return [v*np.cos(theta), v*np.sin(theta), (v/L)*np.tan(alpha)]

sol = odeint(damped_pendulum, [np.pi/4, 0.0], np.linspace(0, 10, 500))

Breakdown. Both functions are literally the state-space models of this module written as code: the returned list is ẋ = f(x, u). The pendulum's second component is the equation of motion you will derive in Ex 7 (with friction term −b·θ̇/(ml²) included, matching Ex 7's setup); the bicycle's third component is the steering law you will meet in Ex 19. Expected output: the damped pendulum's angle oscillates with shrinking amplitude; the bicycle traces a circle of radius L/tan α. Failure case to mention: with a large fixed step, plain Euler makes the pendulum's amplitude grow (energy injection) — the classic reason to use RK4/odeint.

1.4 · The double integrator — your first linear system

Lab Problem 3 (150426); the A/B matrix form is the bridge to the Kalman filter's prediction step in Module 8.

“Double integrator” = you command acceleration, and it integrates twice before reaching position. State (x, y, v_x, v_y), control (a_x, a_y). Because f is linear, the whole step function collapses into two matrices — the structural reason the Kalman filter later gets clean closed-form updates.

Lab Problem 3 · Double Integrator Dynamics ▲ programming task — solution outline independently written (no official solution supplied)

Exam working · ≈3 min Per axis, constant a over Δt the Ex 16 equations again  x_t+1 = x_t + v_x,tΔt + ½a_xΔt², v_x,t+1 = v_x,t + a_xΔt Stack state (x, y, v_x, v_y): x_t+1 = A x_t + B u_t A = 10Δt0010Δt00100001 B = ½Δt²00½Δt²Δt00Δt ✓ check: row 1 reads x + Δt·v_x + ½Δt²·a_x — matches the scalar equation

Breakdown.

1. Solve one axis first with the Ex 16 equations; x and y do not interact, so the 2D system is two copies.
2. “Write it in matrix form” means: arrange coefficients so each state component's update is one row. Read row-by-row to verify — that is also the exam sanity check.
3. The vectorized notebook part: for N simultaneous rollouts, stack states as rows of X̄ (N×4) and controls as rows of Ū (N×2); one step is X̄ = X̄ @ A.T + Ū @ B.T. The transposes appear because rows, not columns, hold the vectors. rollout then needs only the time loop — the batch dimension is handled by the matrix product.

Deeper take. Some notebooks discretize with plain Euler (B has Δt only, no ½Δt² rows). Both are accepted discretizations; the ½Δt² version is exact for piecewise-constant acceleration and is consistent with the official Ex 16 solution, so prefer it on paper and state your choice.

2.1 · Constraints — why wheels can't strafe

Second region of the formula sheet; Ex 22 asks the holonomic/non-holonomic comparison directly; Lab P2 builds on the unicycle model.

A constraint is an invariant the physical system enforces on the state. Two kinds:

• Holonomic: g(q, t) = 0 — a restriction on positions (configuration q). Think database constraint on the row's values. It removes a degree of freedom outright: a train constrained to its track.
• Non-holonomic: A(q, t)q̇ = b(q, t) — a restriction on velocities that cannot be integrated into a position restriction. The state can eventually reach anywhere, but not by any path: a car can parallel park, but not by sliding sideways.

For a wheel with heading θ, the two rows of the constraint story are on your sheet:

• Lateral no-slip: ẋ sin θ − ẏ cos θ = 0 — “velocity component perpendicular to the wheel is zero.” This is the mathematical form of can't strafe.
• Rolling without slip: ẋ cos θ + ẏ sin θ = rφ̇ — “forward speed equals wheel radius times wheel spin rate.” Rolling converts rotation to translation losslessly.

Exercise 22 · Holonomic vs Non-Holonomic Robots

Exam working · ≈2 min (concept answer) (a) Robot A (omnidirectional) is holonomic. (b) Holonomic: can directly command all DOF of its configuration (x, y, θ) —  no velocity constraint. Non-holonomic: velocity constraints forbid some motions  (ẋ sin θ − ẏ cos θ = 0: a diff-drive cannot move sideways). (c) Holonomic: mecanum/omni-wheel platform. Non-holonomic: car, differential-drive robot. (d) Robot A — it can translate sideways without re-orienting first.

Breakdown. Quote the sheet's no-slip constraint in (b) — it is the cleanest possible evidence you understand the definition, and it is sitting on your allowed sheet. The word “directly” matters in the definition: a diff-drive can reach any (x, y, θ), just not by any instantaneous velocity — reachability is not the issue, the velocity space is.

2.2 · Differential drive — two wheel speeds in, (v, ω) out

Ex 8 carries 15 points and full numbers; the formulas are NOT on the sheet — this is the single most valuable memorization item of the course.

Each wheel contributes a ground-contact speed v = rω (that's the rolling constraint). The robot body then averages and differences them:

not on sheet — memorize How to rebuild them if memory fails: equal wheels → straight line at the average speed (so v must be the mean of rω_L, rω_R). Opposite wheels → spin in place about the midpoint: each wheel travels a circle of radius L/2, so ω = (v_R − v_L)/L. Turning radius is just the ratio: a point moving at v while turning at ω traces a circle with v = ωR.

Exercise 8 · Differential Drive Kinematics (15 points)

Exam working · ≈3 min (a) v = r(ω_R + ω_L)/2 = 0.1·(6 + 4)/2 = 0.05 · 10 → v = 0.5 m/s (b) ω = r(ω_R − ω_L)/L = 0.1·(6 − 4)/0.5 = 0.2 · 2 → ω = 0.4 rad/s (c) R = v/ω = 0.5/0.4 → R = 1.25 m ✓ ω_R > ω_L → turns left; R = 1.25 > L/2 = 0.25 → a gentle arc, plausible

Breakdown.

1. Write each green formula before substituting — with 5 points per subpart, the formula line alone earns partial credit.
2. Units: rad/s times m gives m/s because radians are dimensionless — v = rω is the definition of arc speed.
3. (c) reuses your own intermediates (amber): no new given values enter. If your v or ω was wrong, consistent reuse still earns follow-through marks.
4. Sanity checks that cost 5 seconds: equal speeds would give ω = 0 (straight); swapped wheels flips the sign of ω but not v.

Calculator corner (fx-991CW)
Plain Calculate app: 0.1×(6+4)÷2 EXE → 0.5, store: VARIABLE → A → Store. Then 0.1×(6−4)÷0.5 EXE → 0.4 → store in B. Radius: A÷B EXE → 1.25. Numbers this clean are hand-arithmetic — use the calculator only to verify.

Deeper take. The turning radius is measured from the ICC (instantaneous center of curvature), the point both wheel circles share. R = v/ω places the ICC 1.25 m to the robot's left. As ω → 0, R → ∞: a straight line is a circle of infinite radius — the math degrades gracefully, your answer should mention division-by-zero only if v is also 0. Source: official Solution 8 agrees on all values.

2.3 · Unicycle and bicycle models — steering as state update

Ex 19 demands the discrete bicycle model; Lab P2 implements the unicycle; Ex 20–21 interrogate the same equations conceptually.

The unicycle is the minimal non-holonomic model — pose (x, y, θ), controls (v, ω):

The bicycle replaces the direct turn-rate command with a steering angle α acting through the wheelbase L (front wheel steers, rear wheel drives):

not on sheet — memorize Reading it like code: position advances along the current heading (cos/sin split the speed into x/y components — that is the no-slip constraint in disguise), and heading integrates a turn rate v·tan(α)/L. The tan α appears because the front wheel's sideways velocity component v·tan α must be matched by rotation about the rear axle at lever arm L.

Exercise 19 · Bicycle Kinematic Model

Exam working · ≈3 min (a) x_t+1 = x_t + v cos(θ_t)Δt, y_t+1 = y_t + v sin(θ_t)Δt, θ_t+1 = θ_t + (v/L)tan(α)Δt (b) Larger α → larger tan α → larger curvature, smaller turning radius (R = L/tan α). (c) Cars steer their front wheels and cannot rotate in place — matching the bicycle's  geometry; a diff-drive model assumes independently driven left/right wheels.

Breakdown. The only memory item is the θ-update's v·tan(α)/L. Derive-on-demand version: turning radius of a bicycle is R = L/tan α (front wheel offset L ahead, angled α); then θ̇ = v/R = v·tan(α)/L. Notice α = 0 gives θ̇ = 0 (straight), α → 90° gives R → 0 (pivot around rear axle — physically impossible for a car, and tan blows up accordingly).

Exercise 20 · Effect of Control Errors

Exam working · ≈2 min (concept answer) (a) Steering error dominates orientation. (b) Velocity error dominates travelled distance. (c) In θ_t+1 = θ_t + (v/L)tan(α)Δt, α enters the heading directly (and through  the nonlinear tan); v enters distance directly via vΔt in x, y. A heading error then  redirects all subsequent motion, while a distance error stays along-track.

Breakdown. Point at the model, name the term. Deeper marks: steering errors are worse long-term because a wrong heading rotates every future displacement (cross-track error grows with distance travelled), whereas a pure speed error only scales the path. This asymmetry is why odometry drift is dominated by heading noise — a fact Module 8 uses to justify external sensing.

Exercise 21 · Inverse Bicycle Problem

Exam working · ≈2 min (concept answer) (a) No — uniqueness is not guaranteed. (b) The final position leaves (α, v, t) underdetermined: different steering/speed/time  combinations reach the same point; without a required final orientation, several  arcs through the goal exist. (c) Robots rarely need only a point: docking, entering a doorway, grasping, continuing  a path all require a specific final heading.

Breakdown. This is the inverse-problem counterpart of Ex 17 — again counting unknowns vs constraints: a 2D goal position gives two equations; the control space (α, v, duration) has three degrees of freedom. Fixing the final orientation adds the third equation and typically restores (local) uniqueness. Same reasoning template, different vehicle.

Exercise 23 · Motion Uncertainty

Exam working · ≈2 min (concept answer) (a) Wheel slip · uneven ground · actuator error · encoder noise (also: calibration error, control delay) (b) Predicted pose becomes less reliable over time — belief spreads; the robot may  believe a pose far from the true one (dead-reckoning drift, Ex 18). (c) Fuse motion prediction with sensor measurements: predict with the motion model,  correct with observations (Bayes/Kalman filter — Module 8).

Breakdown. Give exactly four sources, physical and distinct (slip and uneven ground are different mechanisms; encoder noise is sensing of the wheel, actuator error is execution). Part (c) wants the predict/correct vocabulary — one sentence naming both steps is a complete answer here.

Lab Problem 2 · Nonholonomic Wheeled Robot Dynamics ▲ programming task — solution outline independently written (no official solution supplied)

class RobotDynamics:
    def feed_forward(self, x, u, dt):          # one Euler step of the unicycle
        px, py, th = x;  v, om = np.clip(u, [-0.75, -1.0], [0.75, 1.0])
        return np.array([px + v*np.cos(th)*dt,
                         py + v*np.sin(th)*dt,
                         th + om*dt]) + disturbance()

    def rollout(self, x0, U, dt):              # N trajectories × T steps
        for n in range(N):                     # loop 1: rollouts
            x = x0
            for t in range(T):                 # loop 2: time
                x = self.feed_forward(x, U[t], dt)
                X[n, t] = x

Breakdown. feed_forward is Euler integration (Lesson 1.3) applied to the unicycle equations (Lesson 2.3): next = current + derivative·dt. The control clip enforces the stated actuator limits |v| ≤ 0.75, |ω| ≤ 1.0. The hint about disturbances is the whole pedagogical point: run the same control sequence N times and the trajectories fan out — a picture of Ex 23's motion uncertainty and the reason rollout needs the outer loop at all.

3.1 · The Lagrangian pipeline: energies in, equation of motion out

Third region of the formula sheet including the fully-worked pendulum special case; Ex 7 assessed it with numbers; Lab P1's damped pendulum implements the result.

Newton's approach needs you to resolve forces and torques — error-prone geometry. Lagrange's approach is a pure pipeline over scalar energies, no force diagrams:

1. Choose a coordinate q that describes the configuration (for a pendulum: the angle θ).
2. Write kinetic energy T = ½mv² (energy of motion) and potential energy V = mgy (energy of height). For a mass on a rod of length l: the speed is v = lθ̇, and the height above the lowest point is y = l(1 − cos θ).
3. Form the Lagrangian L = T − V. (Yes, minus. L is not itself “an energy” — it is the quantity whose stationarity encodes the dynamics.)
4. Run the Euler–Lagrange equation — think of it as the compiler that turns L into the equation of motion:
   ddt ∂L∂q̇_i − ∂L∂q_i = Q_i
   where Q_i collects the non-conservative generalized forces — friction, motor torques. Unforced case: Q_i = 0.

Symbols and where their values come from: m (mass) and l (rod length) are given in the question; g is given or 9.81 ≈ 10 m/s²; θ̇, θ̈ are the unknowns the equation relates; b (friction coefficient, N·m·s/rad) is given only if the question adds friction — and then the sheet will not help you: the friction torque −bθ̇ enters as Q = −bθ̇ on the right-hand side.

Exercise 7 · Pendulum Dynamics

Exam working · ≈4 min m = 2 kg, l = 1 m, b = 0.1 N·m·s/rad, g = 10 m/s², θ = 0 hangs down T = ½ml²θ̇², V = mgl(1 − cos θ) sheet, pendulum block L = T − V = ½ml²θ̇² − mgl(1 − cos θ) ∂L/∂θ̇ = ml²θ̇ → d/dt(∂L/∂θ̇) = ml²θ̈ ∂L/∂θ = −mgl sin θ friction enters as generalized force: Q = −bθ̇ not on the sheet! d/dt(∂L/∂θ̇) − ∂L/∂θ = Q → ml²θ̈ + mgl sin θ = −bθ̇ ml²θ̈ + bθ̇ + mgl sin θ = 0 numbers: 2·1²·θ̈ + 0.1θ̇ + 2·10·1·sin θ = 0 → 2θ̈ + 0.1θ̇ + 20 sin θ = 0 ÷2: θ̈ + 0.05θ̇ + 10 sin θ = 0 ✓ units: each term is rad/s² after ÷ml²; b=0 recovers the sheet's ml²θ̈+mgl sinθ=0

Breakdown.

1. Copy T, V, L from the sheet — free marks for structure. The 1−cos θ in V measures height above the rest position: at θ=0 (hanging) V=0, at the top V=2mgl. Both extremes check out.
2. The two partial derivatives are the only calculus: ∂L/∂θ̇ treats θ as constant (picks the θ̇² term), ∂L/∂θ treats θ̇ as constant (picks the cos θ term, derivative sin θ, sign flips twice — walk it slowly).
3. The exam twist: viscous friction. It is not conservative, so it cannot live inside V — it enters as Q = −bθ̇ (opposing torque proportional to angular speed, exactly like a damping term in a control system). Forgetting Q and answering the sheet's frictionless equation is the predictable error here.
4. Alternative route (equally valid, mention if faster for you): torque balance about the joint, I θ̈ = τ_gravity + τ_friction with I = ml², τ_g = −mgl sin θ, τ_b = −bθ̇ — same boxed equation; the official solution takes this route.

Deeper take. Why sin θ and not θ: gravity's restoring torque depends on the lever arm l sin θ, which shrinks to zero when hanging straight down and is maximal horizontal. For small angles sin θ ≈ θ and the system becomes the linear oscillator θ̈ + (b/ml²)θ̇ + (g/l)θ = 0 — the linearization move that Module 8's EKF applies to everything. Source: official Solution 7 agrees (2θ̈ + 0.1θ̇ + 20 sin θ = 0).

4.1 · Rotation matrices — reading, inverting, composing

“Rigid Transformations” region of the sheet plus the “Useful Values” on page 2; assessed by Ex 3, 4, 5 and reused by every camera exercise.

Everything follows from one reading rule: the columns of R_sa are the axes of frame {a} written in {s} coordinates. Column 1 = where x̂_a points, column 2 = ŷ_a, column 3 = ẑ_a. That's the whole data structure — a rotation matrix is three unit vectors side by side, mutually perpendicular (an orthonormal set).

Consequences you use constantly:

• Inverse for free: R⁻¹ = R^T. Because the columns are orthonormal, R^TR = I. Never row-reduce a rotation matrix.
• Subscript cancellation: R_ab = R_asR_sb = R_sa^TR_sb — adjacent identical subscripts cancel, like function composition through a shared intermediate type. p_s = R_sb p_b: the matrix "converts b-typed points to s-typed points."
• Two readings of R·p: the same multiplication either changes coordinates of a fixed point (if R's subscripts bridge two frames) or moves the point within one frame (if R is used as an operator). Which reading applies is decided by your bookkeeping, not by the numbers — Ex 3(g) tests exactly this.
• Composition side matters: for an orientation R_sa and a rotation operator R: R_saR rotates about a body axis (applied in {a}-coordinates, right side), R·R_sa rotates about a world axis (applied in {s}-coordinates, left side). Mnemonic: the side the operator touches is the frame it lives in.

The professor also circulated a rotation reference (the fig/ sheets): SO(3) membership tests (R^TR = I, det R = 1), the skew matrix [ω], the Rodrigues formula R = I + sin θ[ω̂] + (1−cos θ)[ω̂]², and ZYX Euler angles R = R_z(α)R_y(β)R_x(γ) with all three elementary matrices. Those formulas — including the R_x/R_z matrices the exam sheet omits — are collected in your printable cheatsheet §4.

Exercise 3 · Rotations and Coordinate Frames

Exam working · ≈8 min for all seven subparts (a) drawing below — axes from the given directions, ẑ = x̂ × ŷ (right-hand rule) (b) columns of R are the frame's axes in {s}:  x̂_a=(0,0,1), ŷ_a=(−1,0,0) → ẑ_a = x̂_a×ŷ_a = (0,−1,0)  R_sa = 0−1000−1100 x̂_b=(1,0,0), ŷ_b=(0,0,−1) → ẑ_b = (0,1,0) R_sb = 1000010−10 (c) R⁻¹ = R^T (orthonormal columns): R_sb⁻¹ = R_bs = 10000−1010 (d) R_ab = R_asR_sb = R_sa^TR_sb subscripts cancel  = 001−1000−10 · 1000010−10 = R_ab = 0−10−10000−1 (e) R₁ = R_saR = 00−1010100 — operator on the right:  R₁ rotates R_sa by −90° about the body-fixed x̂_a-axis  R₂ = R R_sa = 0−10100001 — operator on the left:  R₂ rotates R_sa by −90° about the world-fixed x̂_s-axis (f) p_s = R_sb p_b = 1000010−10·(1,2,3) = p_s = (1, 3, −2) (g) p′ = R_sb p_s = (1,3,−2) → moves the point (operator in {s}; s-typed in, s-typed out)  p″ = R_sb^T p_s = R_bs p_s = (1,−3,2) → changes coordinates {s}→{b}, point unmoved ✓ every R above: det = 1, columns unit length — checked

Breakdown.

1. (b) Never guess a rotation matrix entry-by-entry. Build the third axis with the cross product (right-hand rule: x̂ × ŷ = ẑ), then stack the three axes as columns. x̂_a×ŷ_a = (0,0,1)×(−1,0,0) = (0,−1,0) — the cross product of unit axes always lands on another axis, so entries stay 0/±1.
2. (c) The whole point of the subpart: orthonormality makes transposition the inverse. Verify against your drawing — R_bs's columns must be the {s} axes expressed in {b}.
3. (d) Subscript algebra first (R_sa^TR_sb), then multiply. All entries 0/±1: do it by hand, each output entry is a single dot product of a row and a column.
4. (e) is the conceptual heart. Same two matrices, opposite order, different geometric meaning: right-multiplication = body-frame rotation, left-multiplication = world-frame rotation. If this feels arbitrary, trace one axis: R₁'s first column (0,0,1) says x̂ still points at world ẑ — the body x-axis was the rotation axis, unchanged ⇒ body-fixed rotation.
5. (g) p′ keeps the s-type (operator reading, point physically rotated); p″ retypes the same point into {b} (converter reading, R_bs = R_sb^T bridges s→b). The numbers (1,3,−2) vs (1,−3,2) differing is the proof that the two readings are different operations.

Calculator corner (fx-991CW)
Worth using only as a checker here (entries are 0/±1). Matrix app: define MatA = R_sa^T (3×3), MatB = R_sb; CATALOG→Matrix→MatA × MatB EXE reproduces (d). Determinant check: CATALOG→Matrix Calc→Determinant→MatA) EXE → must be 1.

Deeper take. This exercise is the standard frame-fluency test (it originates from the Modern Robotics problem set). Every camera exercise in Module 5 is this exercise wearing a trench coat: “world point → camera coordinates” is (f) with R_cw, and “which reading applies” never comes up again if you always write subscripts. Source: official Solution 3 agrees on every matrix.

Exercise 4 · Rotation Composition

Exam working · ≈6 min with calculator fixed-frame rotations stack on the left: R = R_z(−120°) R_y(135°) R_x(30°) (b) answered first surds from sheet p.2: cos30=√3/2, sin30=½, cos135=−√2/2, sin135=√2/2, cos(−120)=−½, sin(−120)=−√3/2 R_x(30°)=1000√3/2−½0½√3/2 R_y(135°)=−√2/20√2/2010−√2/20−√2/2 R_z(−120°)=−½√3/20−√3/2−½0001 multiply (calculator, exact display): R = √2/4 ¾−√2/8 −√3/4−√6/8√6/4 −√3/4−√6/8 ¼−3√2/8−√2/2 −√2/4 −√6/4 apply to p = (1/√3, −1/√6, 1/√2):  p′ = R p = ( −(2√6+√3)/12, (2√2−1)/4, −(√6+√3)/6 ) ≈ (−0.553, 0.457, −0.697) ✓ ∥p′∥ = 1 = ∥p∥ (rotation preserves length) and det R = 1 — both verified

Breakdown.

1. The one decision in this exercise: which side does each new rotation multiply on? All three rotations are about fixed-frame axes → each premultiplies (left). First applied = rightmost. (Body-frame rotations would postmultiply — Ex 3(e) is the rule's source.)
2. Build the elementary matrices from the sheet's R_y(α) template plus the surd table; watch the sign pattern for R_y (its +sin is top-right, unlike R_x/R_z).
3. The double 3×3 surd product is where hand arithmetic dies. Under exam time: do it on the calculator and transcribe.

Calculator corner (fx-991CW)
Matrix app. TOOLS define MatA = R_z(−120°), MatB = R_y(135°), MatC = R_x(30°) — type entries as −√3÷2 etc. (exact surds are kept). Then CATALOG→Matrix: MatA×MatB×MatC EXE → R. Store p as MatD (3×1): MatAns×MatD EXE → p′. Press FORMAT to toggle exact/decimal. Sanity: Det(MatAns) of R → 1.

⚠ Discrepancy with the supplied solutionThe official Solution 4 lists R and p′ = ((3√6+√2)/8, (√6−3√2)/8, −½) — but that vector has length √1.5 ≈ 1.22, and a rotation cannot change the length of p (which is 1). Its R also contains a row of length < 1, so its matrix product has arithmetic slips. The values above were computed symbolically (SymPy) and check both invariants: ∥p′∥ = 1, det R = 1, R R^T = I. The official solution's method (composition order, elementary matrices) is correct — only its multiplication is off. In the exam, the norm check is your defence: 10 seconds to catch this class of error.

Exercise 5 · Rigid Body Motion

Exam working · ≈4 min rotation center C = (L, L); from the figure P sits distance d below C at θ=0  → r_CP = (0, −d) in the rotating frame planar rotation: R(θ) = cos θ−sin θsin θcos θ (a) P_s(θ) = C + R(θ) r_CP = (L,L) + (d sin θ, −d cos θ)  P_s(θ) = ( L + d sin θ, L − d cos θ ) (b) differentiate, θ̇ = 1: Ṗ_s = (d cos θ·θ̇, d sin θ·θ̇) → Ṗ_s = ( d cos θ, d sin θ ) (c) frame {b} sits at P with orientation R(θ):  T_sb = cos θ−sin θL+d sin θsin θcos θL−d cos θ001 ✓ θ=0: P=(L, L−d) — directly below C, matches the figure

Breakdown.

1. The decomposition center + rotated offset is the universal trick for circular motion: express the fixed pivot, then rotate the constant body-frame offset. All the geometry reading happens in the single line r_CP = (0, −d) — taken straight from the figure in the snippet.
2. (b) is one chain rule; with θ̇ = 1 the answer is the derivative of (a) with θ̇ struck out. Velocity is perpendicular to the offset (dot product of (sin θ, −cos θ) and (cos θ, sin θ) is 0) — circular motion sanity check.
3. (c) A planar homogeneous transform is the 2×2 rotation with the frame origin glued on as the third column, bottom row (0 0 1). The origin of {b} is P itself, so paste in (a).

Deeper take. T_sb packages “where is the body and how is it oriented” into a single matrix so that composing motions becomes matrix multiplication — the same homogeneous trick the camera's [R|t] uses in Module 5. Source: official Solution 5 agrees on all three parts.

4.2 · Homogeneous transforms — position and orientation in one matrix

On the sheet (T, T⁻¹); the camera pipeline's [R|t] and Ex 5(c) both use it; camera sheet Ex 10–13 drill the inverse.

A rigid transform is rotation-then-translation: ^cP = ^cR_W ^WP + ^ct_W. Homogeneous coordinates make it a single multiplication by appending a 1 to the point:

The payoff is the inverse shortcut on your sheet — derived by solving ^cP = R ^WP + t for ^WP (multiply by R^T, move terms):

Note the translation of the inverse is −R^Tt, not −t — the single most common error in camera back-projection tasks. The worked drills live with the camera exercises (Camera 10–13), where this matrix does its real job.

5.1 · The projection pipeline

Largest region of the formula sheet; Ex 9 (15 points); two full drill sheets; ceiling-marker localization (Module 6) is a special case of it.

Four stages, each a one-liner. Think of it as a data pipeline with three coordinate types:

1. World → camera (extrinsics): P_C = R P_W + t. Frame conversion, Module 4 material. R, t describe where the camera is.
2. Camera → normalized: x_n = X_C/Z_C, y_n = Y_C/Z_C. Perspective division — the step that makes far things small, and the only nonlinear step. Requires Z_C > 0 (point in front of camera).
3. Normalized → pixels (intrinsics): u = f_xx_n + c_x, v = f_yy_n + c_y. A scale (focal length in pixel units) and a shift (principal point = image center of the optical axis).
4. All at once, homogeneous: λp̃ = K[R|t]P̃_W — append 1 to the point, multiply, then divide the result by its third component (λ = Z_C). One matrix product instead of three steps.

Symbols and origins: f_x, f_y (focal lengths, pixels), c_x, c_y (principal point, pixels — sometimes written u₀, v₀; s = skew, always 0 in this course) come from K, given. R, t given or built from a stated rotation. Z_C is computed in stage 1 unless the point is already camera-frame. In back-projection, depth is given or the answer stays a ray.

Exercise 9 · Camera Projection (15 points) — the flagship

Exam working · ≈4 min point already in camera coords: P = (1, 2, 5), f_x=f_y=800, c_x=320, c_y=240 (a) x_n = X_C/Z_C, y_n = Y_C/Z_C = 1/5, 2/5 → (x_n, y_n) = (0.2, 0.4) (b) u = f_xx_n + c_x = 800·0.2 + 320 = 160 + 320 → u = 480  v = f_yy_n + c_y = 800·0.4 + 240 = 320 + 240 → v = 560  (u, v) = (480, 560) (c) Intrinsic: internal camera geometry (focal lengths, principal point, skew) — inside K.  Extrinsic: camera pose relative to another frame — R and t; they map world → camera coords. ✓ point is right of and below center (x_n, y_n > 0) and u > 320, v > 240 — consistent

Breakdown.

1. First decision of any camera task: what frame is the point in? Here it says “in camera coordinates” — stage 1 skipped. (The wording is exactly what distinguishes this from Camera 7/16, where a world point forces the extrinsic step first.)
2. (a) is two divisions; keep them as clean decimals. (b) is the K map spelled out — writing the sheet's u, v formulas before substituting earns the structure marks.
3. (c) one crisp sentence each side, naming where they live (K vs [R|t]). Bonus phrase: intrinsics are fixed by the camera hardware, extrinsics change whenever the camera moves.

Calculator corner (fx-991CW)
Calculate app is enough: 800×1÷5+320 EXE, 800×2÷5+240 EXE. Or matrix check: MatA = K (3×3), MatB = P (3×1), MatA×MatB EXE → (2400, 2800, 5); divide first two by 5. Same answer both routes — the homogeneous route is (b) of Camera 6.

Deeper take. Source: official Solution 9 agrees. Notice the two equivalent routes — direct formulas vs K-multiplication + normalization. The homogeneous route generalizes (it's what λp̃ = K[R|t]P̃ does); the direct route is faster for numbers. Pick per task, know both.

5.2 · Guided drill sheet — the forward pipeline, stage by stage

The 060526 sheet exists specifically to rehearse the exam calculation; its own printed solutions are cross-checked below (all values agree unless noted).

The sheet builds the pipeline one stage at a time. Work them in order; each drill below shows the snippet, the working as you would write it, and — only where something is instructive — a remark.

Camera 1 · Coordinate Frames

Working · <1 min aligned frames → R = I, t = 0: P_C = R P_W + t = P_W → P_C = (2, 1, 5)

Remark. The identity case exists to fix the convention in your head: the formula maps world → camera, and “aligned, no offset” must give the same numbers back.

Camera 2 · Translation Only

Working · <1 min P_C = P_W + t = (3−1, 2, 10) → P_C = (2, 2, 10)

Remark. t is added in the camera frame — it is not the camera's position. With R = I the camera center sits at −t = (1, 0, 0): a camera one meter along +x sees the world shifted one meter toward −x. Sign confusion here is the #1 error in inverse tasks later.

Camera 3 · Camera Coordinates to Image Coordinates

Working · 1 min x = f·X_C/Z_C = 2·2/4 = 1, y = f·Y_C/Z_C = 2·1/4 = 0.5 → p = (1, 0.5)

Remark. This is the metric image plane (f in the same length units as the point). The sheet's x_n, y_n are the f = 1 special case. Same operation, different scaling constant.

Camera 4 · Effect of Depth

Working · 1 min P₁: (2·2/4, 2·1/4) = (1, 0.5) P₂: (2·2/8, 2·1/8) = (0.5, 0.25) Same X, Y — twice the depth → image point at half the distance from center.

Remark. Projection scales like 1/Z. This single fact powers the entire ceiling-marker module (scale = f/h) and stereo depth (Module 7).

Camera 5 · Camera Coordinates to Pixel Coordinates

Working · 1 min u = α·X_C/Z_C + u₀ = 800·0.5 + 320 = 400+320 → u = 720 v = β·Y_C/Z_C + v₀ = 800·0.25 + 240 = 200+240 → v = 440 p = (720, 440)

Remark. α, β here are the sheet's f_x, f_y, and (u₀, v₀) is (c_x, c_y) — notation drift between sheets, same objects. Expect either notation in the exam.

Camera 6 · Using the Intrinsic Matrix

Working · 2 min p^h = K P_C = 80003200800240001·(2,1,4) = (800·2+320·4, 800·1+240·4, 4) = (2880, 1760, 4) normalize by 3rd coordinate: u = 2880/4, v = 1760/4 → p = (720, 440) ✓ matches Camera 5 — the two routes must agree

Remark. Key mental shift: K·P_C gives a homogeneous triple whose third entry is the depth; the perspective division happens at the end. This ordering is what lets the whole pipeline chain into λp̃ = K[R|t]P̃.

Calculator corner: Matrix app, MatA = K, MatB = P_C (3×1); MatA×MatB EXE; divide entries 1–2 by entry 3 by hand — the calculator will not do the homogeneous division for you.

Camera 7 · Complete Projection from World to Pixel

Working · 2 min stage 1: P_C = R P_W + t = (3,2,10) + (−1,0,0) = (2, 2, 10) stage 2+3: u = 800·2/10 + 320 = 160+320 → 480; v = 800·2/10 + 240 = 160+240 → 400 p = (480, 400)

Remark. First drill that runs the whole pipeline. In the exam, label the stages exactly as here — “world→camera”, “project” — graders award structure.

Camera 8 · Back-Projection from Pixel to Camera Ray

Working · 2 min invert the intrinsic map: x_n = (u−u₀)/f_x = (720−320)/800 = 0.5  y_n = (v−v₀)/f_y = (440−240)/800 = 0.25 ray direction d_C = (0.5, 0.25, 1) — a direction, not a point: depth unknown

Remark. Undoing K is just undoing “scale then shift”: subtract the shift, divide by the scale. The 1 in the third slot parametrizes the ray: every point Z·(0.5, 0.25, 1) hits pixel (720, 440).

Camera 9 · Back-Projection with Known Depth

Working · 1 min from Camera 8: (x_n, y_n) = (0.5, 0.25); given Z_C = 4 X_C = x_nZ_C = 2, Y_C = y_nZ_C = 1 → P_C = (2, 1, 4) ✓ projecting (2,1,4) with this K gives (720,440) — Camera 5 confirms

Camera 10 · Back from Camera to World Coordinates

Working · 1 min R = I → P_W = P_C − t = (2,2,10) − (−1,0,0) → P_W = (3, 2, 10) ✓ Camera 7 forward gave (2,2,10) from (3,2,10) — round trip closes

Camera 11 · General Inverse Transformation

Working · 2 min (derivation) P_C = R P_W + t subtract t: P_C − t = R P_W multiply by R⁻¹, and R⁻¹ = R^T for rotations: P_W = R^T(P_C − t)

Remark. Expand it: P_W = R^TP_C − R^Tt — the inverse transform's rotation is R^T and its translation is −R^Tt. That is exactly the sheet's T⁻¹ block (Module 4.2). Two-line derivation, worth having cold.

Camera 12 · Rotation Around the Z-Axis

Working · 1 min P_C = R P_W = 0−10100001·(1,0,5) = P_C = (0, 1, 5) world x̂-axis point now lies on the camera ŷ-axis; depth unchanged (rotation about the optical axis)

Camera 13 · Full Projection with Rotation

Working · 1 min u = 800·0/5 + 320 = 320 (dead center in u — X_C = 0) v = 800·1/5 + 240 = 160+240 = 560… careful: 800·(1/5) = 160 → v = 400 p = (320, 400)

Remark. A point with X_C = 0 lands exactly on the vertical center line u = c_x — reading such structural zeros before computing is the fastest self-check available.

Camera 14 · Which Points Are Visible?

Working · 1 min P₁: Z_C = 5 > 0 → visible P₂: Z_C = −2 < 0 → not visible (behind the camera) P₃: Z_C = 0 → not projectable (division by zero — the camera center itself)

Camera 15 · Conceptual Question

Working · 1 min (concept answer) A pixel defines a ray from the camera center; every point on that ray projects to the same pixel. Recovering a point needs extra information: depth sensor, stereo, or known object size.

Remark. The slogan to write: pixel → ray, not point. Camera 8 is this fact as arithmetic; triangulation (Module 7) is the fix — intersect two rays.

Camera 16 · Guided Full Pipeline

Working · 3 min 1. P_C = P_W + t = (4−2, 2, 8) = (2, 2, 8) 2. x_n = X_C/Z_C = 2/8 = 0.25, y_n = 2/8 = 0.25 3. u = 600·0.25 + 320 = 150+320 → 470; v = 600·0.25 + 240 → 390 p = (470, 390)

Remark. The battle plan's Day-1 target. Different K (600, not 800) than earlier drills — read the given K every time; the numbers are deliberately varied between drills to punish formula-sheet autopilot.

Camera 17 · Guided Inverse Pipeline

Working · 3 min 1. x_n = (470−320)/600 = 0.25; y_n = (390−240)/600 = 0.25 2. with Z_C = 8: X_C = 0.25·8 = 2, Y_C = 2 → P_C = (2, 2, 8) 3. P_W = R^T(P_C − t) = (2, 2, 8) − (−2, 0, 0) → P_W = (4, 2, 8) ✓ exact inverse of Camera 16 — round trip closes

Remark. The complete inverse pipeline in three moves: undo K, attach depth, undo the rigid transform. Every inverse camera exam task is this template with different numbers.

Camera 18 · Conceptual Summary

Working · 1 min 1. K contains the intrinsic parameters 2. R, t are the extrinsic parameters 3. pixel with no depth ↔ a ray in 3D 4. depth Z_C must be positive and nonzero 5. homogeneous coordinates make projection a matrix multiplication

5.3 · Variant sheet — same pipeline, fresh numbers

Second practice sheet (060526_2), no official solutions supplied — all answers below independently computed and machine-verified; the conceptual parts follow the course slides' definitions.

Variant 1 · Understanding Coordinate Frames

Working · 2 min 1. no rotation stated → R = I: P_C = P_W + t = (2−1, 1, 5) → P_C = (1, 1, 5) 2. t shifts world points by −1 along x when re-expressed in the camera frame —  equivalently the camera center sits at −t = (1, 0, 0) in the world. 3. sketch: two parallel axis triads offset by 1 m along x (orientations identical).

Variant 2 · Basic Perspective Projection

Working · 2 min 1. x = f·X_C/Z_C = 800·2/4 = 400; y = 800·1/4 = 200 → (x, y) = (400, 200) 2. Z_C ↑ → x, y shrink toward the image center (1/Z scaling). 3. Nonlinear because of the division by the coordinate Z_C — scaling a point's  depth does not scale its image linearly; it is a projective, not affine, map.

Variant 3 · Pixel Coordinates

Working · 2 min 1. u = 700·1/5 + 320 = 140+320 → 460; v = 700·2/5 + 240 = 280+240 → 520 (u, v) = (460, 520) 2. u > u₀ → right of center; v > v₀ → below center (v grows downward). 3. Principal point (u₀, v₀): where the optical axis pierces the image — the origin  offset that converts centered image coordinates into pixel-array indices.

Variant 4 · Intrinsic Matrix

Working · 2 min 1. K = 90006400850360001 2. f_x, f_y: focal length in pixel units per axis; u₀, v₀: principal point; γ: skew (axis shear). 3. γ ≠ 0 when the pixel axes are not perpendicular — sensor manufacturing shear or  legacy analog readout; modern digital sensors: γ = 0.

Variant 5 · Rotation and Translation

Working · 2 min 1. R P_W = 0−10100001·(1,0,2) = (0, 1, 2); + t = (0+1, 1+2, 2+0) → P_C = (1, 3, 2) 2. R is a +90° rotation about ẑ: world x̂ ↦ camera ŷ, world ŷ ↦ −x̂; z unchanged. 3. sketch: axes rotated a quarter-turn in the xy-plane, then shifted by t.

Variant 6 · Full Projection Pipeline

Working · 2 min 1. R = I, t = 0 → P_C = (2, 1, 4) 2. (x_n, y_n) = (2/4, 1/4) = (0.5, 0.25) 3. u = 800·0.5+320 = 720; v = 800·0.25+240 = 440 → p = (720, 440) 4. pipeline drawing: reproduce the four-box diagram from Lesson 5.1.

Variant 7 · Depth Effect

Working · 2 min 1. normalized: P_C1 → (1/2, 1/2) = (0.5, 0.5); P_C2 → (1/8, 1/8) = (0.125, 0.125) 2. same (X, Y), 4× the depth → image position 4× closer to center 3. image size/offset ∝ 1/Z_C — equal physical extents subtend smaller angles when far 4. sketch: two similar triangles sharing the camera center; far triangle → shallower ray angle.

Variant 8 · Homogeneous Coordinates

Working · 1 min 1. append 1: (2, 3) → (2, 3, 1); (4, −1, 5) → (4, −1, 5, 1) (any nonzero multiple is equivalent) 2. back: divide by the last coordinate, drop it. 3. They turn translation + rotation + projection into single matrix multiplications,  so transform chains compose by multiplying matrices.

Variant 9 · Back Projection

Working · 2 min 1. x_n = (400−320)/800 = 0.1; y_n = (300−240)/800 = 0.075 2. ray d_C = (0.1, 0.075, 1), i.e. all points Z·d_C, Z > 0 3. one image measures 2 numbers (u, v) for 3 unknowns — the depth dimension is lost  in the Z-division; need stereo/depth sensor/size prior.

Variant 10 · Camera Calibration Interpretation

Working · 2 min 1. f_x = 1200, f_y = 1180, (u₀, v₀) = (640, 360), skew 0 2. principal point ≈ image center → resolution ≈ 2·(640, 360) = 1280 × 720 3. f_x ≠ f_y: non-square pixels or estimation noise in calibration 4. error sources: corner-detection noise, poor pose variety in calibration images,  unmodelled lens distortion, over/under-fitting the distortion model.

Variant 11 · Radial Distortion

Working · 2 min (concept answer + sketch below) 1. Barrel: straight lines bow outward, away from the image center (worst at the edges). 2. Barrel: magnification falls with radius (wide-angle lenses); pincushion: magnification  grows with radius (telephoto) — lines bow inward. 3. sketch: grids below. 4. Uncorrected distortion breaks the pinhole model — projections,  measurements and triangulation all assume straight rays → correct before calculating.

Variant 12 · Coordinate Transformation Interpretation

Working · 2 min (concept answer) 1. World coordinates of the static object: unchanged — the world frame is fixed. 2. Camera coordinates: depth Z_C decreases by 2 m (object approaches along the axis). 3. Pixels: features move outward from the center and the object grows (1/Z_C shrank). 4. Only relative pose matters: robot +2 m forward ≡ object 2 m closer — the  projection cannot distinguish them.

Variant 13 · Multi-Step Challenge

Working · 4 min 1. R P_W = 0−10100001·(3,2,6) = (−2, 3, 6); + t(1,0,0) → P_C = (−1, 3, 6) 2. (x_n, y_n) = (−1/6, 3/6) = (−0.1667, 0.5) 3. u = 1000·(−1/6) + 640 = −166.67+640 → 473.33; v = 1000·0.5 + 360 → 860 p ≈ (473.3, 860) 4. geometrically: quarter-turn about ẑ re-labels x/y axes, t shifts along camera x̂,  division by 6 projects, K scales+shifts into the pixel array. 5. drawing: pipeline diagram of Lesson 5.1 with these numbers on the arrows. ✓ X_C < 0 → left of center: u < 640 ✓; large y_n = 0.5 → far below center: v = 860 ✓

Calculator corner: MatA = R, MatB = P_W; MatA×MatB EXE; add t by hand. Then 1000×(−1)÷6+640 EXE → 473.33. Keep the fraction −1/6 (press FORMAT for exact) until the last multiplication to avoid rounding drift.

6.1 · The ceiling-marker geometry — one scale factor does everything

Dedicated formula-sheet region plus the page-2 relative-orientation formula; Ex 24 (20 points), 25, 26, 27 all compute with it.

Why this setup is a special case: the camera points straight up, the ceiling is flat, so every marker point has the same depth Z_C = h. The perspective division stops being point-dependent and the whole pipeline becomes a single linear scale:

Read s like a DPI setting: at f = 800 px and h = 4 m, the world is imaged at 200 pixels per meter. Everything in this module is multiplying or dividing by s — the only care needed is direction (world→pixels: multiply by s; pixels→world: divide).

Two consequences the sheet spells out:

• Distance doubles → scale halves: s′ = f/(2h) = s/2. Same 1/Z law as Camera 4, now in scale form.
• Heading from marker orientation: θ_r = θ_m − θ_i — the robot's heading is the marker's known world orientation minus the orientation it appears with in the image. If the marker looks rotated by θ_i in your camera, it is really you who is rotated the other way.

Exercise 24 · Camera-Based Robot Localization (20 points)

Exam working · ≈4 min (a) Fixed, rarely occluded (people/furniture don't block the ceiling), easy to detect,  unlikely to be moved accidentally. (b) s = f/h = 800/4 = 200 px/m → 1 m ↦ Δu = 200 pixels (c) Δu = s·ΔX = 200·0.5 → 100 pixels (d) A rotationally symmetric marker fixes position but not orientation (it looks the  same from any heading). Two markers define a direction between them, which  disambiguates the robot's heading → unique pose.

Breakdown.

1. (b) and (c) are the sheet's s = f/h twice — with 10 of the 20 points on them. Write the formula, plug, done. Note (c) says the robot moves “0.5 m closer” horizontally toward the point under the marker: the marker's image shifts by s·0.5. (The height h does not change — the robot drives on the floor.)
2. (d) is a degrees-of-freedom count: pose has 3 unknowns (x, y, θ); one symmetric marker measures 2 (your offset from it). The missing one is exactly the heading — hence the second marker (or an asymmetric marker, which is why real fiducials like ArUco are asymmetric).
3. The given robot pose (2, 1, 30°) and marker (5, 5) are scene dressing for (a)–(d) — no subpart consumes them. Don't invent a calculation the question didn't ask for.

Deeper take. Source: official Solution 24 agrees. This scenario (TH Deggendorf's ceiling-marker localization) is the course's running example of an absolute position reference — the external sensor that Ex 18(c) said dead reckoning needs. Module 8's filters are how you'd fuse it with odometry.

Exercise 25 · Camera Projection with Ceiling Marker

Exam working · ≈2 min (a) s = f/h = 600/3 → s = 200 px/m (b) Δu = s·ΔX = 200·0.4 = 80 px right of the marker's image center (c) h → 2h: s′ = f/2h = s/2 → scale halves (100 px/m); marker appears half as large

Breakdown. Pure sheet-reading — all three formulas are printed, including (c) verbatim (“If distance doubles: s′ = s/2”). Free 100% if you know where to look; that is why the formula-sheet geography drill exists.

Exercise 26 · Localization Geometry

Exam working · ≈2 min (a) marker at (4, 2); robot 1 m west of it; west = −x:  (4 − 1, 2) → robot at (3, 2) (b) θ_r = θ_m − θ_i = 45° − 20° → θ_r = 25°

Breakdown. (a) is a compass-direction translation: west = negative x (north = +y in the course's map convention). (b) is the page-2 formula: the marker's true orientation is 45°, but the camera sees only 20° of it — the missing 25° is the robot's own rotation. Sanity: if the robot had heading 0°, it would measure the full 45°.

Exercise 27 · Localization Accuracy

Exam working · ≈2 min (a) ΔX = Δu/s = 10/200 → ±0.05 m = ±5 cm (b) Yes — more pixels per meter (larger s) → the same ±10 px is fewer meters.  But real accuracy also depends on calibration, lens distortion, lighting, detection quality —  resolution is necessary, not sufficient.

Breakdown. Error propagation through a linear map is just the same map: pixels of uncertainty divide by s exactly like pixels of displacement. The “but” in (b) earns the second half of the marks — name at least two non-resolution error sources.

Exercise 28 · Landmark-Based Localization

Exam working · ≈3 min + sketch (a) One range fixes only a circle around the landmark; even with bearing, noise and  the unknown heading leave the pose ambiguous. (b) Each landmark adds independent geometric constraints — the intersection of the  constraint sets pins the pose down and averages out noise. (c) sketch below — robot pose, two landmarks, range lines r₁, r₂, bearings β₁, β₂. (d) EKF if a good initial estimate exists (uncertainty ≈ Gaussian, single mode);  particle filter for global localization (can hold multiple pose hypotheses).

Breakdown. The geometry vocabulary matters: range constrains you to a circle, bearing to a ray relative to your unknown heading. Two identified landmarks over-determine the 3-DOF pose, which is what lets a filter both solve it and estimate its confidence. In (d), naming both filters with their applicability conditions is what full marks look like — the official solution does exactly that.

7.1 · Triangulation — intersecting rays to recover depth

Seven of the sheet's 17 exercises; slide deck 6 (13.05.) devotes its first half to it.

One camera gives you a ray per pixel (Camera 8). A second camera, displaced by a known baseline, gives a second ray to the same physical point — and two non-parallel lines meet in (at most) one point. Triangulation = compute that intersection. Because measurements are noisy the rays never exactly meet, so in practice you solve a least-squares problem: stack the constraints from both views into A X̃ = 0 and take the best non-trivial solution via SVD (the right-singular vector of the smallest singular value — the direction A squashes closest to zero). Quality is then measured in the image, not in 3D: the reprojection error ∥p − p̂∥ asks “if the 3D estimate were true, how far off would its predicted pixel be?”

Vision 1 · Understanding Triangulation

Working · 2 min (concept answer) a) Recover a 3D point as the intersection of the viewing rays from ≥2 known camera poses. b) One view leaves depth free (pixel ↦ ray) — the second view supplies the constraint that picks one point on the ray. c) Each observation defines a ray (line) in 3D from the camera center through the pixel.

Vision 2 · Projection Matrix

Working · 2 min a) P = K[R|t] — the full camera map: intrinsics and extrinsics fused into one matrix (sheet: “Full projection model”). b) K is 3×3, [R|t] is 3×4 → P is 3×4. c) p̃ is homogeneous (3-vector, scale-free, third entry ∝ depth); p is Euclidean — divide p̃ by its third entry.

Vision 3 · Homogeneous Coordinates

Working · <1 min divide by the third coordinate: (400/2, 200/2) → p = (200, 100)

Vision 4 · Linear Triangulation

Working · 2 min (concept answer) Each view gives λp̃ = P X̃ — p̃ and P X̃ must be parallel (same ray, unknown scale λ). Eliminating λ (cross product p̃ × P X̃ = 0) yields 2 independent linear, homogeneous equations in X̃ per view; stacking ≥2 views gives A X̃ = 0 — homogeneous because X̃'s overall scale is arbitrary.

Vision 5 · SVD Solution

Working · 2 min a) The last column of V — the right-singular vector of the smallest singular value. b) X̃ = 0 is excluded (trivial); among ∥X̃∥ = 1 the minimizer of ∥A X̃∥ is the  direction A stretches least — σ_min's singular vector; with noise A X̃ = 0 holds only approximately, so we minimize instead of solving exactly.

Vision 6 · Reprojection Error

Working · 1 min p − p̂ = (320−312, 200−198) = (8, 2) ∥p−p̂∥₂ = √(8² + 2²) = √68 = 2√17 ≈ 8.25 px

Calculator corner: √(8²+2²) EXE → 2√17; FORMAT → 8.2462. Exact form first, decimal second.

Vision 7 · Effect of Baseline

Working · 2 min a) System B (50 cm) — a wider baseline makes the two rays intersect at a larger angle,  so the same pixel noise moves the intersection less in depth. b) Less view overlap and harder feature matching (the scene looks more different  between views; more occlusion; nearby objects may leave one view entirely).

Remark. Same 1/Z intuition as always: depth error grows with Z²/(f·b) — baseline b sits in the denominator. Accuracy vs matchability is the design trade-off every stereo rig makes.

7.2 · Structure from Motion — stereo with one moving camera

Sheet Ex 8–10 and 16; the pipeline-ordering question is a classic quick-marks format.

SfM answers: what if the “two cameras” are one camera at two (or many) times? Then the camera poses are unknown too, and you must estimate structure (3D points) and motion (camera poses) jointly, from feature correspondences alone. The pipeline is fixed vocabulary — learn it as an ordered list, and know that bundle adjustment is the final polish: a nonlinear least-squares pass minimizing the total reprojection error over all poses and points simultaneously.

Vision 8 · Structure from Motion

Working · 2 min (concept answer) Stereo: two cameras, fixed and calibrated relative pose (known baseline) — depth from one synchronized pair. SfM: one moving camera, unknown poses — structure and camera motion estimated together from many views; scale is unobservable without extra information.

Vision 9 · SfM Pipeline

Working · 1 min 1. feature detection → 2. feature matching → 3. camera pose estimation → 4. triangulation → 5. bundle adjustment

Remark. Logic beats memory: you can't match features before finding them; matches are what pose estimation consumes; triangulation needs poses; bundle adjustment refines everything, so it must be last.

Vision 10 · Bundle Adjustment

Working · 1 min All camera poses and all 3D points jointly, minimizing the sum of squared reprojection errors Σ ∥p_ij − proj(P_i, X_j)∥² over every observation.

Vision 16 · Conceptual Matching

Working · 1 min Triangulation → recover 3D points Optical flow → estimate apparent motion SfM → jointly estimate structure and motion Bundle adjustment → refine reconstruction

7.3 · Optical flow — one equation, two unknowns

Sheet Ex 11–13 include the sheet's only flow computation; the aperture problem is a favorite concept question.

Optical flow estimates the apparent pixel motion (u, v) between consecutive frames. Its foundation is brightness constancy — a moving point keeps its intensity — whose first-order Taylor expansion gives the flow equation:

not on sheet — memorize I_x, I_y are the image's spatial intensity gradients, I_t the temporal change (all measurable from the frames); u, v the unknown flow. One equation, two unknowns — underdetermined at a single pixel, which is the aperture problem: only the flow component along the gradient (perpendicular to an edge) is observable.

Vision 11 · Optical Flow

Working · 1 min I_xu + I_yv + I_t = 0: 2·1 + (−1)v + (−3) = 0 −v − 1 = 0 → v = −1 ✓ substitute back: 2 + 1 − 3 = 0

Vision 12 · Brightness Constancy

Working · 1 min Brightness constancy: a scene point's image intensity stays constant as it moves — I(x+u, y+v, t+1) = I(x, y, t) (plus, implicitly, small motion for the linearization). Fails under lighting change, specular reflections, occlusion.

Vision 13 · Aperture Problem

Working · 1 min Along an edge the intensity doesn't change, so motion parallel to the edge produces no image change — only the component along the gradient is observable. One flow equation, two unknowns: through a small “aperture” infinitely many (u, v) fit the data.

7.4 · Event cameras — pixels that report changes

Two short sheet exercises; slides mention them as an outlook topic. Definitions suffice.

A conventional camera reads out full frames at a fixed rate. An event camera's pixels fire independently and asynchronously whenever their local log-brightness changes past a threshold — think interrupt-driven I/O instead of polling. Output: a sparse stream of events instead of images. Payoff: microsecond latency, huge dynamic range, no motion blur; cost: no absolute intensity, algorithms must be rewritten for event streams.

Vision 14 · Event Cameras

Working · 1 min Traditional: synchronous, fixed frame rate · outputs full frames Event camera: asynchronous events · outputs sparse per-pixel brightness-change events

Vision 15 · Event Representation

Working · 1 min (x, y): pixel location · t: timestamp of the change (µs resolution) · p: polarity — brightness increased (+1) or decreased (−1)

Vision 17 · Reflection Question

Working · 2 min (concept answer) Projection destroys information (3D → 2D: depth lost, Camera 15), so an image is consistent with infinitely many world states. Vision must infer the most plausible state from incomplete, noisy data plus prior assumptions (rigidity, brightness constancy, smoothness) — estimation under uncertainty, not deterministic decoding. The same logic motivates the probabilistic filters of Module 8.

8.1 · The Bayes filter — predict, then correct

Ex 1 opens the collection with it; Ex 10 (15 points) computes it; Ex 23, 28, 29 all lean on its vocabulary. Absent from the formula sheet.

The state is now a distribution, not a number: bel(x_t) = the probability of every candidate state given everything seen so far. Two functions you already met keep it updated — but now they push distributions instead of points:

• Predict (motion model p(x_t | u_t, x_t−1)): push the belief through the motion model. Like Ex 16's error growth, this spreads the belief — motion adds uncertainty.
  bel(x_t) = ∫ p(x_t | u_t, x_t−1) bel(x_t−1) dx_t−1
• Correct (sensor model p(z_t | x_t)): reweight each candidate state by how well it explains the measurement, then renormalize. This sharpens the belief.
  bel(x_t) = η p(z_t | x_t) bel(x_t)

not on sheet — memorize And the engine inside the correction step is plain Bayes' rule:

Dev translation: prior = your cached estimate; likelihood = how compatible the new data is with each hypothesis; normalization = making the weights sum to 1 again so they stay probabilities.

Exercise 1 · Bayes Filter and EKF

Exam working · ≈3 min (concept answer) (a) Prediction: propagate the belief with the motion model and control —  “where could the robot be after this command?” (uncertainty grows).  Update/correction: reweight the predicted belief by the measurement likelihood,  normalize — “which predicted states are consistent with what the sensor saw?” (uncertainty shrinks). (b) p(x_t | u_t, x_t−1): motion/transition model — probability of reaching x_t from x_t−1 under control u_t.  p(z_t | x_t): sensor/measurement model — how likely measurement z_t is if the state is x_t.  bel(x_t): belief — posterior over states given all controls and measurements so far.

Breakdown. Write each answer as name + what it maps + which question it answers. The two-step description earns full marks when it mentions both the mechanism (motion model / sensor model) and the effect on uncertainty (grow / shrink). Source: official Solution 1 agrees.

Exercise 10 · Bayesian Localization (15 points)

Exam working · ≈4 min P(A)=0.7, P(B)=0.3, P(z|A)=0.9, P(z|B)=0.2 P(z) = P(z|A)P(A) + P(z|B)P(B) = 0.9·0.7 + 0.2·0.3 = 0.63 + 0.06 = 0.69 P(A|z) = P(z|A)P(A)/P(z) = 0.63/0.69 → P(A|z) ≈ 0.913 P(B|z) = 0.06/0.69 → P(B|z) ≈ 0.087 ✓ 0.913 + 0.087 = 1; sensor favored A (0.9 vs 0.2) so belief in A rose above the 0.7 prior — direction correct (b) after multiplying prior × likelihood the numbers (0.63, 0.06) are only proportional  to probabilities; dividing by P(z) makes them sum to 1 so the posterior is a valid distribution.

Breakdown.

1. Layout matters: compute the normalizer P(z) once, as its own labeled line — both posteriors divide by it, and the line itself carries marks.
2. The two sanity checks cost nothing: posteriors sum to 1, and the belief moved toward the hypothesis the sensor favored.
3. Keep fractions until the end: 0.63/0.69 = 63/69 = 21/23 ≈ 0.913. Rounding early is how 0.91 becomes 0.9 becomes lost marks.

Calculator corner (fx-991CW)
0.9×0.7+0.2×0.3 EXE → 0.69, store in A (VARIABLE→A→Store). Then 0.63÷A EXE → 0.913…, and 0.06÷A EXE → 0.0869…. FORMAT shows 21/23 exact.

Deeper take. This two-cell world is the Bayes filter correction step, executed once by hand. Ex 29's “multi-modal belief” is this with more cells and less decisive likelihoods; the Kalman filter below is this with a continuous Gaussian instead of two cells. Source: official Solution 10 agrees.

8.2 · Kalman filter and EKF — Gaussians make it tractable

Ex 11 (10 points) asks for exactly these explanations; Ex 2 is a full EKF modeling exercise; Ex 28/30 ask when EKF is appropriate.

The Bayes filter's integral over all states is intractable in general. The Kalman filter is the special case with an exact, cheap answer: if the belief is Gaussian, the models linear, the noise Gaussian — then predict and correct keep it Gaussian, and only the mean μ and covariance Σ need storing (a struct of two fields instead of a whole distribution):

not on sheet — memorize the roles, reproduce the shapes Read them as software: the innovation z_t − C_tμ̄_t is the diff between what the sensor said and what you expected it to say; the Kalman gain K_t is a learned blend ratio — trust the measurement more when your prediction is uncertain (Σ̄ big) and less when the sensor is noisy (Q big). R_t is process noise (motion sloppiness), Q_t measurement noise.

The EKF (extended KF) handles nonlinear f and h — rotations, camera projections — by linearizing at the current estimate: A_t = ∂f/∂x, C_t = ∂h/∂x (Jacobians — the multivariable chain rule you used in Ex 6). Same two-step loop, matrices recomputed each step.

Exercise 11 · Kalman Filter Concepts (10 points)

Exam working · ≈3 min (concept answer) (a) Prediction: use the motion model + control to estimate the next state before the  measurement arrives; propagates mean and covariance; uncertainty grows (process noise adds). (b) Update: correct the prediction with the measurement — compare expected vs actual  (innovation), blend by the Kalman gain; uncertainty shrinks. (c) A Gaussian is fully described by mean and covariance, and stays Gaussian under  linear models with Gaussian noise → closed-form, efficient updates of just (μ, Σ).

Breakdown. The grading skeleton for (a)/(b) is: which model is used + what it produces + what happens to uncertainty. For (c), the two halves are “compact representation” and “closed under the filter's operations” — give both. Source: official Solution 11 agrees.

Exercise 2 · Track My Tethraedron

Exam working · ≈6 min State — everything needed to predict the future: position, orientation (axis-angle to stay a vector), both velocities:  x_t = (p_t, a_t, v_t, ω_t) ∈ ℝ¹² with a_t = r2a(R_t) Controls — nothing commands the body: u_t = ∅ (it drifts under its own velocities) Measurements — each point q_i projects to a pixel pair: z_i ∈ ℝ², four points:  z_t = (z₁, z₂, z₃, z₄) ∈ ℝ⁸ Transition — copy the given dynamics, noise enters through the velocities:  v_t = v_t−1 + n_v, ω_t = ω_t−1 + n_ω, p_t = p_t−1 + v_tΔT,  a_t = r2a( a2r(a_t−1)·a2r(ω_tΔT) ) → x_t = f(x_t−1) + n_t, n_t = (0, 0, n_v, n_ω) Observation — object point → world → camera → pixels (Module 5 pipeline):  ẑ_i = proj( K T⁻¹ X_t q_i ), X_t = [a2r(a_t) | p_t; 0 1] Filter choice: rotations + camera projection are nonlinear → EKF,  Jacobians A_t = ∂f/∂x ∈ ℝ^12×12, C_t = ∂h/∂x ∈ ℝ^8×12 (stacked) or 2×12 per point.

Breakdown.

1. Modeling questions have a fixed template — state, control, measurement, transition, observation — and this exercise hands you the transition equations; your work is choosing containers and dimensions. Count dimensions out loud (3+3+3+3 = 12; 4 points × 2 pixels = 8): stated dimensions are what graders scan for.
2. Orientation is stored as axis-angle a_t (a 3-vector) rather than the 9-entry matrix R_t so the state stays a vector the EKF can add noise to; a2r/r2a shuttle between forms.
3. The observation function is literally Module 5's pipeline with T⁻¹ (camera pose inverted — sheet formula!) and the object's own pose X_t composed in front.
4. A second valid model (official solution notes it): treat velocities as controls u_t = (v_t, ω_t) with a 6-dim state (p, a) — noise then reads as control noise. Say which you chose.

Deeper take. This is the course's capstone modeling exercise — it stitches Module 1 (state), Module 4 (rotations, T⁻¹), Module 5 (projection) and this module (EKF) into one answer. If you can reproduce this table cold, you have functionally covered four modules. Source: official Solution 2 agrees, including both modeling variants.

8.3 · SLAM — localize and map at the same time

Ex 12 (15 points) asks all three classic SLAM questions verbatim.

Localization assumed a known map (Ex 28); mapping assumes a known pose. SLAM (Simultaneous Localization And Mapping) drops both assumptions and solves the circular dependency by estimating pose and map jointly: in EKF-SLAM the landmark coordinates simply become extra state variables, and the same predict/correct loop runs on the enlarged state.

Exercise 12 · SLAM (15 points)

Exam working · ≈3 min (a) Localization needs a map; mapping needs the pose. A wrong pose inserts landmarks  at wrong places; a wrong map corrupts the pose estimate → must estimate both together. (b) pose + both landmark positions in one vector:  y_t = ( x, y, θ, m_1x, m_1y, m_2x, m_2y )^T ∈ ℝ⁷ (c) Deciding which observed measurement corresponds to which map landmark. Hard with  similar-looking landmarks, noise, partial views; a wrong association updates the wrong  landmark and can corrupt the whole filter.

Breakdown. For (b), the only trap is forgetting the pose or a coordinate — count: 3 (pose) + 2 per landmark = 7, state the dimension. For (c), the money sentence is the consequence: mis-association is catastrophic, not merely noisy, because the EKF commits to it. Source: official Solution 12 agrees.

Deeper take. Note what Ex 28(d) established: EKF-SLAM works when uncertainty is unimodal; ambiguous environments (Ex 29) break the Gaussian assumption and demand multi-hypothesis approaches (particle filters). Those three exercises form one story the exam can quiz from any side.

8.4 · Localization scenarios — applying the theory

Ex 29–32 are scenario questions; 29 and 30 have official solutions, 31–32 are the course's reasoning-heavy finale.

Exercise 29 · Ambiguous Environments

Exam working · ≈3 min (concept answer) (a) Identical rooms produce identical laser scans — the measurement cannot distinguish them. (b) The belief becomes multi-modal: several separate poses are simultaneously plausible. (c) Move to where scans differ (corridor, doorway); add uniquely identifiable landmarks  (also valid: integrate odometry over time; add another sensor modality). (d) Yes — a unique landmark makes the likelihoods differ, collapsing the wrong mode.

Breakdown. The keyword being tested is multi-modal — and its implication: an EKF (one Gaussian = one mode) cannot represent this belief; a particle filter can. Say that and (b) is airtight.

Exercise 30 · Underwater Robot Localization

Exam working · ≈3 min (a) travel time → d = v_sound·Δt → distance to the beacon (b) each distance puts the robot on a sphere around that beacon;  intersecting several spheres pins down the 3D position (trilateration). (c) x = (x, y, z); add (ẋ, ẏ, ż) if velocity should be estimated too. (d) the compass already gives orientation exactly — the EKF only estimates unknowns.

Breakdown. The range-measurement geometry is Ex 28 lifted to 3D: circle → sphere. Part (d) states a design principle worth remembering for any modeling question: known quantities are inputs, not state. Source: official Solution 30 agrees.

Exercise 31 · Open-Loop Localization in Grid Environments no supplied solution — independently generated, verified by exhaustive belief-state search (previous build) and re-checked by hand for grid (a)

The idea: with no sensors at all, the robot can still localize by driving into walls on purpose — each M collapses many possible positions onto the same boundary cell. Track the set of possible cells (a belief with equal weights); a solution is a command program that shrinks the set to one cell for every start.

(a)

(b)

(c)

(d)

(e)

(f)

Exam working · answers per grid (rows 1–7 top→bottom, cols 1–6 left→right) (a) M L M L M — 3 M's → final cell (7, 1)  M: everything collapses to row 1 (or the cell under the block); L,M: to column 1; L,M: to the SW corner (b) L M L M L M R M R M L M — 6 M's → (7, 1) (c) L L M L M L M L M L M R M L M — 7 M's → (7, 1) (d) L L M L M L M L M — 4 M's → (1, 3) (e) R M R M R M R M R M L M — 6 M's → (1, 6) (f) impossible — no open-loop L/R/M program ever collapses the belief to one cell:  its corridors keep at least two hypotheses at distinct trap endpoints under every program  (exhaustive search over all 176 reachable (belief set, heading) states found no singleton).

Breakdown.

1. Method to show on paper: write the current set of possible cells, apply each command to every member simultaneously, and repeat. Walls are the information source: M is a projection that maps whole corridors onto their end cells.
2. Work grid (a) once fully by hand (three lines, shown in the comment above) — it demonstrates the method; for the others state sequence, M-count, final cell.
3. For (d)-style impossibility claims, the acceptable exam argument is exhibiting two start cells whose hypotheses never merge — you don't need the exhaustive search, just one stubborn pair.

Exercise 32 · Open-Loop Localization with Step Counting no supplied solution — independently generated, verified by exhaustive observation-history search (previous build)

Exam working · answers per grid (a) shortest sequences (final cell now may depend on the observed counts):  (a) M L M L M (3 M's) → (7,1) (b) L M L M L M R M (4) → (5,6) or (7,6)  (c) L L M R M R M (3) → (1,1), (1,3) or (6,3) (d) R M R M R M (3) → (7,1) or (7,5)  (e) R M L M L M (3) → (1,1) or (1,4) (f) M L M L M L M (4) → (1,6), (5,2), (5,6) or (7,4) (b) each M's count is a measurement: keep only hypotheses whose predicted distance  matches the observed one — the count partitions and prunes the belief set. (c) strictly easier: same physics, extra observations. Grid (f), impossible in Ex 31,  becomes solvable in 4 M's. The final cells need not coincide — knowing which cell you're in suffices. (d) grid (d), R M R M R M: start (1,1) observes counts [0, 6, 0] → ends (7,1);  start (1,3) observes [3, 6, 1] → ends (7,5). Different endpoints, but the count  histories differ, so the robot knows which one it reached.

Breakdown. The conceptual leap the exercise wants stated: in Ex 31, M was only an action; the step count upgrades it to action + measurement — a full Bayes-filter cycle (predict with M, correct with the count). Success is redefined accordingly: not “all starts converge to the same cell” but “the observation history identifies the final cell.” That reframing sentence is the answer to (b) and (c) in one.

9.1 · Open-loop vs closed-loop control

Formula-sheet region “Open-Loop and Closed-Loop Control”; the open-loop concept is assessed via Ex 31–32 and the labs' feed-forward functions.

Three control laws, escalating in awareness:

• Open-loop: u(t) = u_planned(t) — replay a precomputed schedule, never look at reality. A cron job. Drifts under disturbance (Lab P2 demonstrated it).
• Closed-loop (policy): u(t) = π(x(t)) — the control is a function of the measured state. A request handler: input state, output action.
• Linear feedback: u(t) = K(x_ref(t) − x(t)) — the workhorse special case: push proportionally to the error. Big error, big correction; the gain K sets how aggressively.

Why feedback wins: errors get measured and cancelled instead of accumulating (Ex 18's drift is exactly what open-loop suffers). Cost: needs a sensor and can oscillate if K is too aggressive — the trade every thermostat and every PID controller makes.

9.2 · Graph search — Dijkstra and A*

Ex 13 (10 points) asks the comparison verbatim; slides give A* a worked trace. Not on the formula sheet.

Discretize the world into a graph (grid cells, waypoints); planning = shortest path. Both algorithms grow a frontier from the start, always expanding the node with the smallest score f(n):

not on sheet — memorize g(n) = cost from start to n (known, accumulated); h(n) = estimated cost from n to goal (the heuristic — e.g. straight-line distance). Vocabulary that earns marks:

• Admissible: h never overestimates the true remaining cost → A* stays optimal. (Straight-line distance is admissible — you can't beat a straight line.)
• Consistent: h obeys the triangle inequality along edges → nodes never need reopening.
• h ≡ 0 turns A* into Dijkstra — Dijkstra is A* with a maximally uninformed heuristic.

Exercise 13 · Motion Planning (10 points)

Exam working · ≈4 min (concept answer) (a) Dijkstra: f(n) = g(n) · A*: f(n) = g(n) + h(n)  Optimality: Dijkstra optimal for non-negative edge costs; A* optimal if h is admissible  (never overestimates).  Heuristic: Dijkstra uses none (uninformed); A* uses h(n) to aim at the goal.  Efficiency: A* usually expands far fewer nodes — the search is goal-directed;  with h ≡ 0, A* degenerates to Dijkstra. (b) A good heuristic reduces expanded nodes (more informed → more focused search)  while staying admissible to preserve optimality. Overestimate → may miss the best path;  too weak → behaves like Dijkstra and wastes computation.

Breakdown. Structure the comparison by the three named axes — the question literally lists your headings. The two formulas are the anchor; every claim hangs off them. For (b), the tension to articulate: informative (large h, close to true cost) vs admissible (h ≤ true cost) — the best heuristic is the largest one that never lies upward. Source: official Solution 13 agrees.

Deeper take. If asked for a trace: maintain an open list sorted by f; pop the smallest, expand neighbors, update g-values, repeat until the goal is popped. On a grid with obstacles, Dijkstra's expansion front is a circle; A*'s is an ellipse stretched toward the goal — that picture is worth a sentence in any efficiency answer.

10.1 · Finite-state machines for robot behavior

Ex 14 (10 points) demands a drawn FSM plus a trade-off; the delivery-robot example comes straight from the slides.

Exactly the state machines you know: states = behaviors (discrete modes), transitions = events/conditions. Robot FSMs add one convention worth copying: a global interrupt-style transition (“battery low → Recharge from anywhere”) that would be an on* guard in code.

Exercise 14 · Finite State Machines and Decision Making (10 points)

Exam working · ≈4 min (diagram below + 2 sentences) (a) transitions: Idle →(delivery request)→ Navigate →(arrived)→ Deliver →(done)→ Idle;  Idle/Navigate/Deliver →(battery low)→ Recharge →(battery full)→ Idle draw as graph, label every edge (b) Advantage: simple, interpretable, easy to implement and verify — each state is a clear  behavior, transitions are explicitly checkable.  Limitation: scales poorly — states/transitions explode with task complexity, and FSMs  handle uncertainty poorly (no notion of belief or probabilistic outcomes).

Breakdown. Grading an FSM drawing is mechanical: all four states present, every edge labeled with its trigger, and the battery-low interrupt not forgotten (the official solution routes it from Idle and Navigate at minimum — including Deliver is also accepted). For (b), give one advantage and one limitation, each with a “because” — a bare adjective earns half.

10.2 · Reinforcement learning and ROS — the vocabulary

Ex 15 (10 points) is a pure definition check; the slides close the course with both topics.

RL in one loop: an agent in state x picks action u via a policy, the environment returns a scalar reward and the next state; the objective is a policy maximizing cumulative reward. Note the connection to your sheet: the closed-loop control law u = π(x) printed there is exactly what RL calls a (deterministic) policy — RL is learning π from data instead of deriving it from a model.

ROS in one sentence: a robot's software as microservices — processes (nodes) exchanging typed payloads (messages) over named pub/sub channels (topics), with a discovery service (the ROS 1 master) so publishers and subscribers find each other; the data itself flows peer-to-peer.

Exercise 15 · Reinforcement Learning and ROS (10 points)

Exam working · ≈4 min (concept answer) (a) RL:  State — the agent's current situation (pose, sensor readings, task status).  Action — a decision/control the agent chooses (move forward, turn, grasp).  Reward — scalar feedback rating the action in that state; the agent maximizes the cumulative sum.  Policy — the mapping from states to actions, u = π(x) (or stochastic π(u|x)); the thing RL learns. (b) ROS:  Node — a running process doing one job (camera driver, planner, controller).  Topic — a named channel nodes publish to / subscribe to.  Message — the typed data structure sent over a topic (image, velocity command, pose).  Master — the ROS 1 name service that lets nodes find each other; actual traffic is peer-to-peer.

Breakdown. Eight definitions, ~1.25 points each: one precise sentence plus one concrete example per term is the full-marks pattern. The differentiators graders look for: reward is scalar and the objective is cumulative (not greedy per-step); the master only brokers discovery — saying it relays all messages is the classic error. Source: official Solution 15 agrees.