MIT 6.034 is one of the most complete introductions to artificial intelligence ever recorded on video. Patrick Winston taught it at MIT for over 30 years, and the lecture recordings on MIT OpenCourseWare and YouTube have been watched by hundreds of thousands of people who never set foot in Cambridge.
What makes 6.034 different from most AI courses is Winston's emphasis on representation and algorithms. You do not just learn what AI techniques do — you learn why they are structured the way they are, what problems they are solving, and how human cognition informed their design. Winston regularly connects computational ideas back to questions about human intelligence, which makes the material stick in a way that purely technical treatments often do not.
These MIT 6.034 notes are organized by unit, following the course structure. They are meant as a study reference and a complement to watching the lectures, not a replacement.
Watch the first lecture to hear Winston's framing of the course:
For a parallel treatment of classical ML from a practitioner's perspective, see the Andrew Ng ML course notes. If you are working through multiple MIT/Stanford lecture series, the guide on reverse-engineering college courses from YouTube covers the meta-strategy.
Unit 1: Search — How Do We Find Solutions?
Winston opens the course with search because it is the backbone of a huge portion of AI. Many problems that look different on the surface — route planning, game playing, theorem proving, scheduling — reduce to searching a state space for a path from a start state to a goal state.
Depth-First and Breadth-First Search
The two canonical uninformed search algorithms:
Depth-First Search (DFS): explore as far as possible before backtracking. Uses a stack (LIFO). Memory-efficient but not guaranteed to find the shortest path. Can get trapped in infinite branches if cycles are not detected.
Breadth-First Search (BFS): explore all neighbors at the current depth before going deeper. Uses a queue (FIFO). Guaranteed to find the shortest path (when all edges have equal cost) but memory-intensive — the frontier can grow exponentially.
The state space representation matters enormously. For a given problem, the choice of what constitutes a "state" and what counts as a "transition" can make the difference between a tractable search and an intractable one.
Heuristic Search and A*
Uninformed search ignores the structure of the problem. Heuristic search uses problem-specific knowledge to guide the search toward the goal.
Best-first search: expand the node that looks most promising according to a heuristic h(n) — an estimate of the cost to reach the goal from node n.
A search*: combine the actual cost from the start (g(n)) with the heuristic estimate (h(n)):
f(n) = g(n) + h(n)
A* is optimal (finds the shortest path) and complete (always finds a solution if one exists) when h is admissible — it never overestimates the true cost. This is a critical property. An admissible heuristic is always an underestimate.
Winston's famous example: for pathfinding on a map, straight-line distance is an admissible heuristic for road distance (roads are never shorter than straight lines). Manhattan distance is admissible for grid movement without diagonals.
Consistency (monotonicity) is a stronger property: h(n) ≤ cost(n, n') + h(n') for every successor n' of n. Consistent heuristics are always admissible and ensure A* never expands a node more than once.
The practical takeaway: designing a good heuristic is often the hardest part of applying A* to a new problem. Admissibility is required; optimizing the tightness of the heuristic (how close it is to the true cost) determines how fast A* runs.
Unit 2: Constraint Propagation — Solving Problems Without Search
Search is powerful but expensive. Many problems have structure that can be exploited to prune the search space dramatically before you start searching. Constraint propagation is the technique.
Arc Consistency and the AC-3 Algorithm
A constraint satisfaction problem (CSP) has variables, domains for each variable, and constraints between variables. The goal is to assign values to variables such that all constraints are satisfied.
Arc consistency: a variable X is arc-consistent with respect to variable Y if, for every value in X's domain, there exists at least one value in Y's domain that satisfies the constraint between them. If a value in X's domain has no compatible value in Y's domain, it can be safely removed.
The AC-3 algorithm enforces arc consistency by repeatedly processing pairs of variables:
- Initialize a queue with all arcs in the CSP
- For each arc (X, Y): remove from X's domain any value with no compatible value in Y's domain
- If X's domain shrinks, add all arcs (Z, X) back to the queue
AC-3 is O(cd³) where d is the maximum domain size and c is the number of constraints. It dramatically reduces the search space before any search begins.
Backtracking with Forward Checking
Even after constraint propagation, some search is usually necessary. Backtracking search assigns variables one at a time and backtracks when a contradiction is reached.
Forward checking combines constraint propagation with backtracking: whenever a variable is assigned, immediately propagate the constraints to detect failures early. This avoids exploring subtrees that are guaranteed to fail.
Winston demonstrates this clearly with the map-coloring problem: coloring a map such that no two adjacent regions have the same color. With forward checking, many contradictions are detected before they are explicitly expanded.
The insight from this unit: the interplay between propagation and search is what makes modern SAT solvers and constraint solvers fast. Pure search without propagation is almost always intractable for real problems.
Unit 3: Games — Search with an Adversary
Two-player zero-sum games (chess, checkers, Go, tic-tac-toe) require a different kind of search because you are not just searching for a path — you are searching against an opponent who is actively trying to defeat you.
Minimax
The minimax algorithm models the game as a tree where you alternate between maximizing your score (your turns) and minimizing your opponent's score (their turns):
- MAX nodes: pick the child with the highest value
- MIN nodes: pick the child with the lowest value
At leaf nodes, a static evaluation function (heuristic) estimates who is winning and by how much. For chess, this might be based on material balance, piece mobility, king safety, and pawn structure.
The depth of the search tree determines play quality and computation cost. Search to depth d requires O(b^d) node evaluations, where b is the branching factor.
Alpha-Beta Pruning
Alpha-beta pruning eliminates branches that cannot possibly affect the final decision:
- Alpha: the best value MAX has found so far on the path to the root
- Beta: the best value MIN has found so far on the path to the root
When a MAX node finds a value ≥ beta, prune the remaining children (MIN would never allow this). When a MIN node finds a value ≤ alpha, prune the remaining children (MAX would never accept this).
With perfect move ordering (best moves first), alpha-beta reduces the effective branching factor from b to √b, effectively doubling the searchable depth for the same computation budget.
Winston's key point: alpha-beta is not a heuristic. It produces the same result as minimax but faster. The pruning is sound.
Progressive Deepening and Killer Heuristic
In practice, game-playing programs use iterative deepening (search to depth 1, then 2, then 3...) because the time available for a move is unknown in advance. The overhead is small because the last iteration dominates.
The killer heuristic improves move ordering by remembering moves that caused cutoffs at other nodes at the same depth and trying them first. Good moves tend to be good across many positions.
Unit 4: Machine Learning — Learning from Data
This unit covers the machine learning content in 6.034, which is more conceptual than the coverage in Andrew Ng's course but more focused on the foundational ideas.
Nearest Neighbor Methods
The simplest learning algorithm: given a new example, find the training example closest to it (by some distance metric) and predict the same label.
k-Nearest Neighbors (k-NN): instead of using only the single nearest neighbor, take a vote among the k nearest. More robust to noise.
Key properties of k-NN:
- Non-parametric: no model is fit; the training data is the model
- Lazy learning: no training time; all computation happens at prediction time
- The curse of dimensionality: in high-dimensional spaces, all points become approximately equidistant, making nearest-neighbor search less meaningful
Winston emphasizes that k-NN works surprisingly well in practice and demonstrates the key principle that representation matters: the choice of features and distance metric determines whether nearest-neighbor is meaningful.
Decision Trees and ID3
Decision trees classify examples by asking a sequence of questions about the features. The tree is learned from data using a greedy top-down algorithm.
ID3 (Iterative Dichotomiser 3) uses information gain to select which feature to split on:
Gain(S, A) = Entropy(S) - Σ (|Sᵥ|/|S|) × Entropy(Sᵥ)
where the entropy of a set S is:
Entropy(S) = -Σ pᵢ log₂ pᵢ
The feature with the highest information gain is selected at each node. This greedy choice does not guarantee the optimal tree but works well in practice.
Overfitting is a real problem for decision trees: a tree can perfectly classify the training data by splitting on irrelevant features. The fixes: limit tree depth, require a minimum number of examples per split, or prune the tree after building it.
Boosting
The core idea of boosting: combine many weak learners (classifiers slightly better than random) into a strong learner.
AdaBoost iteratively trains classifiers, reweighting the training examples after each round so that misclassified examples get more attention. The final classifier is a weighted vote of all trained classifiers.
Winston's key insight about boosting: it is one of the few cases where we have strong theoretical guarantees that the ensemble is more accurate than its components. The training error decreases exponentially with the number of rounds.
Unit 5: Neural Networks — Structure and Learning
6.034's neural network unit is memorable for Winston's emphasis on the biological parallels and the historical development of the field.
Perceptrons and Their Limits
A perceptron computes a weighted sum of inputs and outputs 1 if the sum exceeds a threshold:
output = 1 if w·x + b > 0, else 0
The perceptron learning rule adjusts weights when a prediction is wrong:
w ← w + α(y - ŷ)x
Convergence theorem: if the training data is linearly separable, the perceptron learning algorithm will converge in finite steps. If the data is not linearly separable, it will loop forever.
Minsky and Papert's 1969 analysis showed that a single perceptron cannot compute XOR — a linearly inseparable function. This insight (combined with the political climate of the time) contributed to the first AI winter. Winston covers this history clearly and fairly.
Backpropagation in 6.034
The solution to the linearly inseparable problem: add hidden layers. A network with at least one hidden layer can approximate any continuous function (universal approximation theorem).
The challenge: how do you train the hidden layers? The error signal is clear at the output, but the hidden units have no direct targets.
Backpropagation solves this by propagating the error backward through the network, using the chain rule to compute the gradient at each layer. Winston's presentation focuses on the intuition: each hidden unit receives a share of the output error proportional to how much it influenced the output.
The historical significance: backpropagation was known by researchers in the 1970s but not widely applied until Rumelhart, Hinton, and Williams' influential 1986 paper demonstrated it clearly on multi-layer networks.
Unit 6: Genetic Algorithms — Evolution as Search
Genetic algorithms model the search process on biological evolution. They are most useful for problems where:
- The search space is large, multimodal, and discontinuous
- The fitness function is complex and hard to differentiate
- The structure of good solutions is not obvious in advance
The Basic Algorithm
- Initialize a population of random candidate solutions (individuals), each encoded as a string (the genome)
- Evaluate each individual's fitness using the objective function
- Select parents for reproduction — individuals with higher fitness are more likely to be selected
- Crossover: combine two parent genomes to produce offspring (e.g., one-point crossover: take the first k genes from parent 1, the rest from parent 2)
- Mutate: randomly flip bits in offspring genomes with small probability
- Replace the old population with the new generation
- Repeat until convergence or budget exhausted
Why Does It Work?
Winston introduces the schema theorem to explain why genetic algorithms work. A schema is a pattern that matches a set of genomes (e.g., 10 matches any 4-bit string starting with 1 and ending with 0). Short, high-fitness schemas are called building blocks.
The schema theorem says that building blocks with above-average fitness proliferate exponentially across generations. Crossover combines building blocks from different individuals. The hypothesis: good solutions are built from combinations of good partial solutions.
This explanation is somewhat idealized — the schema theorem has known limitations — but it provides the right intuition: GAs work best when the problem has combinable structure (the building-block hypothesis holds).
Where GAs Fail
GAs are slow compared to gradient descent for problems with smooth, differentiable landscapes. They work best for discrete, combinatorial optimization. Common failure modes:
- Premature convergence: the population converges to a local optimum before finding the global one. Fix: maintain diversity (fitness sharing, niching).
- Deceptive problems: problems where good partial solutions combine to form poor complete solutions. The building-block hypothesis breaks down.
Unit 7: Summary and the Bigger Picture
Winston closes the course with a reflection on what unifies all these techniques: they are all methods for representing knowledge and using that knowledge to reason.
Search finds paths through state spaces. Constraint propagation uses explicit constraints to prune those spaces. Game trees model adversarial reasoning. Machine learning acquires knowledge from data. Neural networks learn distributed representations. Genetic algorithms evolve knowledge.
The common thread: every technique involves a choice of representation (how to encode the problem) and a process (how to use that encoding to find answers). Improvements in AI come more often from better representations than from better algorithms.
This is Winston's intellectual legacy in AI: the emphasis on representation as the fundamental question. It predates the modern deep learning era, but it anticipates it. Deep learning's central insight — that learned representations are better than hand-engineered ones for many tasks — is entirely consistent with Winston's framing.
How Should You Study 6.034?
The lecture videos are MIT's gift to the world: 30 lectures, clear blackboard explanations, memorable examples. Watch them at 1.5x speed the first time (see our guide on speed-watching YouTube lectures without missing anything), then review your notes before the next lecture.
The problem sets require careful reading — the 6.034 problems are designed to expose misconceptions, not just test rote knowledge. Work through them before looking at solutions.
For structured note-taking from technical lecture series, see our full guide on YouTube to notes and the overview of AI-assisted study notes.
The MIT OpenCourseWare page for 6.034 contains all lecture slides, problem sets, and exams.
Is 6.034 Still Relevant in 2026?
The short answer is yes, for the right reasons. The deep learning revolution has not made search algorithms, constraint propagation, or the theory of decision trees obsolete — those are the foundations that the new work builds on.
What 6.034 does not cover: transformers, large language models, reinforcement learning (covered in other MIT courses), or modern training infrastructure. For those, you need later courses. But the clarity of Winston's explanations, the historical perspective, and the emphasis on foundational reasoning make 6.034 worth studying even if you end up working entirely on deep learning systems.
Winston passed away in 2019. The lectures are his monument. They are worth your time.
When you work through dense lecture series like 6.034, the bottleneck is rarely access to the material — it is converting video hours into structured, reviewable notes. Notiq handles that automatically: paste in a transcript, get organized notes and flashcards back. Try it at notiq.study.
