Set the foundation: define what "complexity" actually means as a claim, and meet the three modes of proof — analytical, empirical, and structural — you'll use to defend complexity claims throughout the course. Learn to recognize falsifiable vs. unfalsifiable performance claims and build the worked-example habit you'll need in later modules.

Empirical proof in practice: measure runtime with reproducible benchmarks. Three head-to-head Python→Rust translations — list comprehension to iterator, dict lookup to HashMap, and sorted() to sort_unstable — let you read benchmark output, control for noise, and decide when measured speedups are real and when they're artifacts.

Structural proof in practice: use the type system to make incorrect programs impossible to compile. Translating Optional[T] to Option<T>, try/except to Result<T,E>, and ad-hoc state machines to Rust enums turns runtime errors into compile-time errors — a structural guarantee no benchmark can refute.

Translation with runtime consequences: each translation in this module replaces a Python construct (generators, subprocess calls, parallel loops) with a Rust equivalent that carries different runtime guarantees — memory profile, error surface, parallelism model — not just "the same thing, but faster."

Capstone: bring all three modes of proof together on a real translation. Two case studies — a three-mode playbook end to end, and a deliberate "when NOT to translate" example — train your judgment about when a Python→Rust port pays off and when it would just add cost without measurable benefit.