AI Beyond Machine Learning
IB Syllabus: none directly. This is a stretch page: nothing on it is examined. It sharpens A4.1.1 (by showing what machine learning is not, and by going behind two applications the syllabus list names, robotics navigation and object detection), and it feeds A4.4.1 (the explainability contrast), A4.1.2 (why feasibility matters) and A4.3.10 (how method choice is reasoned about). SL and HL both welcome.
Why read this. Most students treat “AI” and “machine learning” as the same word. They are not. For most of its first fifty years the field was symbols, logic, search and geometry, with no training and no data, and that older half still runs games, route-finders and robots today. Here is the page’s central claim, and it is checkable: you can get a robot across a building with almost no learning anywhere in the system. Knowing this half makes machine learning itself easier to understand, because you finally see what it replaced and what it did not. (Written July 2026 from sources spanning 2019 to 2026.)
Table of Contents
- The Map: Three Blocks
- Block One: Knowledge and Reasoning
- Block Two: Search Where Something Pushes Back
- Block Three: Search Where the World Is Indifferent
- What This Page Leaves Out
- Where This Connects
The Map: Three Blocks
This page has three blocks, and one organising question runs through the last two.
- Knowledge and reasoning: facts written down as symbols, and new facts derived by logic.
- Search where something pushes back: game playing, where every move you consider meets an opponent’s best reply.
- Search where the world is indifferent: route-finding and robot motion, where the obstacles are merely there.
A quick historical frame, because it explains the order: games came first in AI research (a famous eighteenth-century chess “machine” turned out to be a hoax with a person inside, and real chess and draughts programs were among computing’s earliest projects). Games offer a bounded world, fixed rules, an objective score and unlimited practice, which is everything a research field could want. The knowledge block came alongside, and robots came once the other two were understood.
Block One: Knowledge and Reasoning
Stretch. This is the cleanest possible foil for A4.1.1: an approach that uses no data and does no training at all. Its explainability payoff feeds A4.4.1 directly, which is in the syllabus.
Symbolic AI (sometimes called good-old-fashioned AI) makes decisions by writing the world down and applying logic to it. A symbol names a thing; a relation describes it or links it to another: teaches(Ms Rivera, Physics). This is deliberately unlike the vectors on the other stretch pages. It is readable. A person can look at it and say “true” or “false”.
The same knowledge, held two ways. This one picture frames the whole page.
A knowledge base is the collection of statements the system holds true. Building one is a design task, not a training run. Logic supplies the machinery: propositions (statements that are true or false), the connectives AND, OR and NOT, and truth tables to settle results. The workhorse is implication, the if/then rule, and its behaviour is worth one careful beat: “if it is raining, the match is cancelled” is broken only by rain and an uncancelled match. Every rule-based system is stacked out of that one shape.
Inference is the payoff, and the reason this is more than a database: the system derives true statements nobody typed in.
Whether you agree with a derived conclusion is itself a good discussion: a rule-based system is exactly as sensible as its rules, and it will follow one off a cliff without hesitating. (One source lecture famously derives that a hot dog is a sandwich by this route; build your own examples and argue about them instead.)
Try it: derive facts nobody wrote down. A school library system holds four statements. Rules: any item with a story and a spine is a book; any book on the reserve shelf may not leave the library. Facts: the graphic novel has a story and a spine; the atlas is on the reserve shelf. What can the system derive, and what can it not derive that might surprise you?
Show the derivations
It derives that the graphic novel is a book. If a librarian later shelves the graphic novel on reserve, it derives that the graphic novel may not leave. But it cannot conclude that the atlas may not leave: nothing says the atlas is a book (an atlas has a spine but arguably no story, and the system knows only what it is told). That surprise is the honest lesson twice over: inference gives you exactly what the rules entail, no more, and whether “story” was the right condition for bookhood is a design decision a human made, and can be blamed for.
Expert systems put this to work: a large body of if/then rules built to stand in for a specialist in a narrow domain. And here is the hinge of the whole page. An expert system can explain itself. Asked why an application was refused, it can name the rule that failed and the value that triggered it. A trained network, asked the same question, has no trace to point at.
The explainability contrast, and it should be taught as a live trade-off rather than a complaint: the systems that can explain themselves are also the ones that cannot cope with messy input. When A4.4.1 asks about accountability and the “black box”, this picture is the concrete version. (Quick exercise: write the refusal letter each system could send. One letter writes itself; the other cannot honestly be written.)
Where symbols fail is exactly where machine learning begins. Try writing logical rules that recognise a hand-drawn “7”: every attempt drowns in exceptions, because perception is not made of crisp propositions. Messy input, intuition and a changing world are where the symbolic approach runs out, and that collapse is the reason the rest of the A4 topic exists.
The same idea at web scale
Writing every fact by hand does not scale, so knowledge can be gathered by reading. A crawler follows links outward from a starting page, and an inverted index records, for every word, which pages contain it, so a query is answered by intersecting lists rather than by reading anything at the moment you search. Ranking the results is where a little learning quietly creeps back in, and the training signal is you: a quick return to the results page suggests a poor answer; a click followed by a long stay suggests a good one. Users label the data for free, all day, every day.
A knowledge base can even grow itself by bootstrapping: start from a handful of hand-written facts, use known relationships to find new objects, use known objects to find new relationships, repeat. Confidence comes from repetition: a fact seen across many independent sources gets trusted; a fact seen once is held as merely possible. That last sentence is also, word for word, a decent rule for your own reading online, which is worth noticing.
Block one in one sitting: symbols and relations at 2:19, knowledge bases at 3:44, truth tables at 4:30, implication at 7:15, inference at 9:44, expert systems at 10:52, the explainability contrast at 11:45 and the limits at 12:04. From 2019; nothing here has dated, because none of it depends on the state of the art.
Watch: search engines and knowledge at web scale (Crash Course AI, 11 min)
The crawler and seed pages at 3:02, an inverted index answering a query at 3:41, ranking and why users supply the training signal at 4:55, knowledge bases at scale at 6:32, and a knowledge base growing itself from three hand-written facts at 7:00. From 2019: treat named systems as examples of their moment; the mechanisms stand.
Block Two: Search Where Something Pushes Back
Stretch, with one term that earns an in-syllabus tag: exploration versus exploitation is named in A4.3.6 (HL), and this block is where it shows up outside reinforcement learning. Also feeds A4.1.2: the feasibility wall below is the reason hardware points exist. The spine of this block comes from a long unedited lecture that cannot be embedded, so the chain of ideas is written out here in full, with the worked examples on video where an embeddable source exists.
A terminology collision, before anything else. One of this block’s sources uses “decision tree” for a hand-written flowchart of questions for choosing a move. The syllabus (A4.3.2) uses the same two words for a completely different thing: a classifier learned from labelled data. The names collide; the concepts do not overlap. If you carry the game-playing picture into A4.3.2, it will quietly wreck your understanding there, so leave it at this page’s door.
Start with hand-written rules, and let them fail. A strategy for a simple game can be written as questions: can I win this move? If not, can my opponent win next move, so that I must block? Draw it as a flowchart and it works, briefly. Then keep asking “and what if neither applies?” until the plan visibly runs out, which takes about three questions. That failure is what motivates everything below.
Minimax is the first real method. Score the endings: +1 for a win, 0 for a draw, -1 for a loss. One player wants the number high, the other wants it low. To evaluate an unfinished position, follow each branch to its endings and pass values back up: at your turns, take the best child; at your opponent’s turns, assume they take the worst for you.
Worked from the endings backwards: the opponent’s left branch guarantees 0, so you take the draw rather than gamble on the loss. The greyed branch is alpha-beta pruning in action: the moment the right branch revealed a -1 available to the opponent, that branch could at best equal a loss, so its remaining endings were skipped entirely. A real saving, and, as the next paragraph shows, still not enough.
Try it: minimax by hand, then break its assumption. Sketch any two-moves-from-the-end position in a game you know, score the endings +1, 0, -1, and pass values up.
Then ask the sharper question
What changes if your opponent plays badly? Minimax assumed they always choose the move worst for you. Against a weak or random opponent, the “safe” branch may not be the best practical choice, and seeing that assumption exposed tells you what kind of thing minimax is: not a law of games, just a policy of preparing for the strongest reply.
Now hit the wall, with numbers. The tree multiplies with every turn. Put two games side by side: one with nine opening moves, one with twenty. After two turns, seventy-two branches against four hundred. Play the small game out completely and there are roughly 260,000 ways it can go, which a computer checks in seconds. The bigger game passes through the trillions within nine turns, which is out of reach, and larger games are worse again, with more possible positions than there are atoms in the observable universe.
The branching wall. The principle to keep, because it matters far beyond games: a method that would work given unlimited time is not good enough. Efficiency is part of the problem, not a refinement of it. That principle is also the honest bridge to A4.1.2, and one of the working reasons machine learning took over jobs like these.
Try it: count the branches yourself. Multiply the first four turns: 9 × 8 × 7 × 6 against 20 × 19 × 18 × 17.
Check your arithmetic and finish the thought
3,024 against 116,280, after only four turns. At a million positions checked per second, the first is instant and so is the second, which is the trap: extend to nine or ten turns and the second number has left the realm of seconds entirely while the first has stopped growing (the small game simply ends). Growth rate, not current size, is what kills you.
Two patches, and what each costs. A depth limit stops the look-ahead after a set number of moves, which creates a new problem: an unfinished position has no score. An evaluation function estimates one, and hand-built evaluations are fragile: counting pieces says one side is winning, and in one position it is right, while in another the same count is exactly wrong because position matters more than material. Feeling the pull towards “let the system work the evaluation out for itself” at this exact moment? That pull is the bridge from this page back to machine learning.
Monte Carlo tree search takes a different route entirely: judge a move by playing the rest of the game out at random, many times, and counting wins. Two candidate moves, a hundred random playouts each: one wins 41, the other 78. Take the second, without anyone understanding why it is better. How many playouts are enough? Increase the number until the answer stops changing, and accept that every playout costs time. Inside this method sits a dilemma with a syllabus name, exploration versus exploitation (A4.3.6, in the syllabus at HL): a barely-tried branch with a poor record might still be better than the well-tried favourite, and deciding how often to revisit it is the same trade-off a reinforcement learner faces.
A strategy written as questions, minimax worked backwards from the endings, and exact counts of how many ways the game can be played. The segment ends at 28:59. Reminder from the warning above: when this lecture says 'decision tree', it means a hand-written flowchart, not the A4.3.2 classifier.
Watch: the history and the gentle version (Crash Course AI, 11 min)
The history timeline ready-made from 2:18 (including the chess hoax with a person inside), a plain-language pass at game trees, minimax and random playouts from 4:28, and an honest closing note at 9:55 on what remains hard. From 2019.
Block Three: Search Where the World Is Indifferent
Stretch, and the block with the strongest syllabus connection: robotics navigation and object detection are both applications named in A4.1.1’s list, and this is the machinery behind the first of them, with the second arriving at the end. One honest note up front: no student-facing video exists for the planning algorithms in this block (the lecture that teaches them is a long unedited recording), so the diagrams here are not illustrations of the content; they are the content. The robotics framing, sensing and control do have a good video, embedded below.
The contrast that opens this block is the cleanest organising idea on the page. Game search faces an opponent actively working against you. Map search faces walls that are merely there. The same idea, exploring possibilities before acting, splits into two families depending on whether anything pushes back.
One idea, two families. Block two was the left half; everything below is the right.
The teaching structure of this block is a sequence of deliberately unrealistic assumptions, removed one at a time. Watch for the pattern; it is worth stealing for your own explanations of anything.
Finding a route
Start with a grid: a robot in a maze, a start, a goal. Depth first search follows one path until it dead-ends, backs up to the last junction, and tries the next option. It finds a route. Now ask the question that drives the rest of the block: was it the shortest?
Breadth first search answers differently: check everything one step away, then everything two steps away, then three. Because it spreads outward evenly, the first time it touches the goal must be via a shortest route. That guarantee is worth pausing on: it does not come from cleverness, it comes purely from the order of exploration.
The same maze, twice. An honest detail: in this maze both searches examined 21 of the 24 open squares, so the difference is not effort saved, it is the guarantee bought. Try it yourself on squared paper with a maze of your own; half the class tracing each search is the cleanest algorithm comparison one sheet of paper can buy.
Relax the grid into a graph (places as nodes, connections you may travel as edges) and both searches run unchanged: the world can now be towns on a road trip rather than squares.
Then break it: not all connections are equal. Give each road a cost in minutes, tolls or fuel, and breadth first search immediately gives wrong answers, because fewest hops is not cheapest: a four-road route costing 13 loses to a longer route costing 9. Dijkstra’s algorithm repairs the guarantee by always expanding the cheapest reachable place next, whatever the hop count.
Try it: cheapest is not shortest. Sketch five towns where the direct-looking route has four short roads costing 13 minutes total, and a longer-looking route costs 9. Which would you want from a navigation app?
Then push it one step further
Change the costs from minutes to tolls, and ask whether the best route changes. It usually does, and that is the real lesson: “best” depends entirely on what you are counting. Method choice following from the cost you care about is precisely the reasoning A4.3.10 wants at HL, with one caveat attached: these are search algorithms, not machine learning models, so borrow the reasoning pattern, never the examples.
Then break Dijkstra’s patience: it does far too much work. Look at which squares breadth-first examined in the maze above: the entire dead-end pocket, pointing directly away from the goal.
The shaded picture is the entire argument for heuristics, in one frame. But take the obvious objection seriously: if we are heading towards the goal, why not always jump to whichever point looks closest to it? Because a point that took fifteen steps to reach can be worse than one that took two and looks slightly further. Balancing distance already travelled against estimated distance remaining is A star search, and raising the objection yourself before accepting the answer is the best discussion this block offers. Two honest costs of a heuristic, kept honest: sometimes no available move looks good and you follow the guess through awkward moments anyway; and a bad guess can mislead. Finally, replanning: when obstacles appear and clear while you are already moving, recompute, and preferably recompute only what changed.
The robot is not a point
Here is the biggest hidden assumption of all, and breaking it is the difference between path planning (does a route exist?) and motion planning (can this physical object actually travel it?). A car cannot slide sideways into a parking space, even though the space is directly adjacent. Knowing a route exists is not the same as being able to move along it.
A machine’s configuration is its full physical state, not just its position: a car has a heading; a four-jointed robotic arm is described by four angles, not by where its hand happens to be. Reasoning about an awkward shape at every step is hard, so engineers use a bounding shape: wrap the robot in a circle big enough to contain it. The rule is deliberately conservative, and worth stating properly: if every point of the robot sits inside the circle, then any route safe for the circle is safe for the robot. (Want more precision? Use several smaller circles.)
Then comes the move that changes the whole problem, and the best idea in this block: grow every obstacle by the circle’s radius.
Thicken the walls, shrink the robot to a dot, and route-finding for a shape becomes route-finding for a point through a world whose grey borders mark where the centre may not go. The two drawings describe the same world; only one answers at a glance.
Try it: the fattened walls, on paper. Draw a floor plan with a doorway, and a robot drawn to scale as a circle. First decide by eye whether it fits through. Then redraw the plan with every wall thickened by the circle’s radius and the robot as a dot.
What you should notice
The second drawing answers the question instantly: the dot fits wherever any un-thickened space remains. If the thickened walls meet across the doorway, the robot does not fit, and no cleverness in the route-finder can change that. You have converted a geometry problem into the maze problem you already know how to search.
Two more assumptions fall in quick succession, each with an honest cost attached:
- Real space is continuous, so there are infinitely many positions to consider. Sampling-based planning scatters random candidate points, discards any inside an obstacle or its grown border, and searches the survivors. The two costs: the route found may not be the best one, and an unlucky scattering can miss the only way through even though it exists.
- Real obstacles are not rectangles. Cell decomposition covers them with a grid and blocks any cell an obstacle touches at all, and doing so can wrongly seal a gap that a slightly obstructed cell only partly filled. The repair: subdivide the blocked cells into four and look again, repeating until a way through appears (or genuinely none does).
An approximation shown failing and then repaired teaches more than one presented as flawless. Both honest costs above are the price of making an infinite problem finite.
Where am I, actually?
The last assumption to break is the quietest: that the robot knows where it is. Position technology is never perfectly precise, so a machine holds a spread of likely positions rather than one certain point. A sensor reading arrives and the spread tightens; the robot moves, and the spread loosens again, because how far it actually travelled is itself an estimate. Combining readings over time keeps the estimate honest. Working out where you are is localisation; doing it while simultaneously building the map you are localising against is SLAM (simultaneous localisation and mapping), named here in one sentence because that is all this page’s sources support.
Position held as a probability cloud. A caution for HL students: this looks like a data-cleaning topic (A4.2.1) and is not one. Preparing a dataset before training and a vehicle estimating its own position in real time are different activities; the resemblance is a trap, not a link.
Sensing the world pairs two instruments with opposite strengths: cameras give appearance, and LiDAR gives geometry, sending out a pulse of light and timing its return across many angles. LiDAR still works in the dark when a camera does not; a camera reads a road sign that LiDAR sees only as a flat rectangle. Combining them lets each cover the other’s weakness.
The human-scale framing for this block: the three core problems of robotics at 2:04, the unfamiliar-building analogy at 2:24, sensing and SLAM from 2:52, planning as actions with steps and conditions at 5:05, and the control material (keeping a physical machine on its plan) from 6:24, which nothing else on this page covers. From 2019.
Where learning re-enters
Right at the end, the two halves of the field meet, and it makes the perfect close. In the syllabus: object detection is an application named in A4.1.1’s list, and here is what is behind it. Finding objects inside an image (not labelling the whole image, but drawing a box around each pedestrian and cyclist) works by proposing many candidate regions cheaply and permissively, being deliberately relaxed about wrong guesses, and then running a trained network on each region to say what, if anything, it contains. The honest engineering caution comes attached: doing that thousands of times per frame on a moving vehicle is too slow, which is why real systems combine the work into fewer passes (a speed-up that has been standard practice since the mid-2010s).
So the finished robot stack reads: symbolic maps and search decide where to go (no learning), grown obstacles and sampling decide how to move (no learning), a probability cloud tracks where it is (no learning), and a trained network reads the camera (learning, exactly where symbols failed: perception). That division of labour, not “AI equals machine learning”, is the true picture, and it is the single most transferable thing on this page.
What This Page Leaves Out
An honest list. None of these is covered by this page’s sources:
- Constraint satisfaction problems (timetabling, map colouring, sudoku), a major classical territory that teaches the same ideas well.
- How inference is actually carried out as a procedure, and logic beyond simple true/false propositions (the notation with variables and quantifiers you may see elsewhere).
- Probabilistic reasoning as a named field. The localisation material above is exactly this territory, and the standard named tools for it are absent here, so know that names exist to look up.
- The expert-system boom and bust of the 1980s, the most instructive historical episode in this half of the field.
- The bookkeeping of pruning, named A star guarantees, and the data structures (priority queues, frontiers) underneath the searches: methods here are described by behaviour only.
- Named sampling-based planners and formal treatments of SLAM and planning languages.
- Multi-agent and swarm systems.
- Ethics for this half of the field. Striking, given the sources discuss self-driving cars: they contain no ethics treatment at all. Do not mistake that silence for there being nothing to say; accountability when an autonomous vehicle harms someone is an A4.4.1 discussion waiting to happen, and the explainability contrast above is where to start it.
Where This Connects
- In the syllabus: What Machine Learning Is (A4.1.1: this page is the “and is not” half of “what machine learning is”, plus the machinery behind two named applications, robotics navigation and object detection; A4.1.2: the branching wall is why hardware and feasibility matter).
- In the syllabus (HL): Types of Learning for the real decision trees (A4.3.2) and for reinforcement learning (A4.3.6), where exploration versus exploitation reappears with rewards attached; Training and Evaluating a Model for model selection reasoning (A4.3.10, reasoning pattern only) and CNNs (A4.3.9, the network inside object detection).
- In the syllabus: Ethics of Machine Learning (A4.4.1): the explainability contrast is this page’s gift to that discussion.
- Stretch: How Large Language Models Work and How AI Image Generation Works cover the trained half of the field; this page is their deliberate opposite.
- Elsewhere on EduCS: the searching ideas here rhyme with Searching Algorithms (B2.4.2), and the graphs with Data Structures; those pages are assessed material, this one is not.
Sources and dates for this page
Built July 2026 by rewording and reorganising ideas from: Crash Course AI episodes on Symbolic AI, Web Search, Robotics and AI Playing Games (all embedded or linked above, 2019); CS50x 2026 “Artificial Intelligence” (search segment embedded above, 2026); and two lectures from CS50’s “Fundamentals of AI” series, “Playing” and “Moving” (2026), which are long unedited live recordings, linked for completeness rather than embedded: Lecture 0 and Lecture 6. All worked examples, mazes and diagrams on this page are original.