Artificial Intelligence

Today "AI" almost always means machine learning — but the field is much older and much broader. Classical, or symbolic, AI is about making a machine reason: search through possibilities, apply logic, and plan a sequence of actions toward a goal. No training data, no neural nets — just an explicit model of the problem and a clever way to navigate it.

This page is the classical foundation, and it completes the foundation tier. It matters for two reasons: these techniques still run real systems (route planners, schedulers, game engines, solvers), and understanding them is what lets you see where machine learning actually sits in the bigger picture of "making machines act intelligently."

What AI actually means

There's no single definition, but the most useful framing is the rational agent: an entity that perceives its environment and acts to achieve the best expected outcome given its goals. "Intelligence" here isn't mystical — it's doing the right thing, given what you know. The field has always had two broad approaches:

Symbolic AI (this page) — represent knowledge explicitly as symbols and rules, and reason over them by search and logic. Transparent and provable, but brittle when the world is messy.
Statistical AI (machine learning) — learn behaviour from data rather than hand-coding it. Robust to messiness, but opaque.

Most of this page is symbolic, because that's the foundation the word "AI" was built on — and because the modern systems you admire usually stitch the two together.

Problem-solving as search

A huge slice of classical AI reduces to one idea: search. Frame a problem as a space of states you can move between, and "solving" it becomes finding a path from where you are to where you want to be. Every search problem has five parts:

States — the possible configurations (a board position, a city you're in).
Initial state — where you start.
Actions — the legal moves from a state.
Goal test — how you recognise you've arrived.
Path cost — what each step costs, so you can prefer cheaper solutions.

Searching builds a tree: the root is the start, branches are actions, and you expand nodes outward looking for a goal. The whole art is the order in which you expand — because the tree is usually far too big to explore fully.

Uninformed search

Uninformed (or "blind") strategies have no clue which direction the goal is in — they just systematically explore. Two anchors:

Breadth-First Search (BFS) — expand all nodes at one depth before going deeper. It finds the shallowest (fewest-step) solution, but its memory cost explodes exponentially with depth.
Depth-First Search (DFS) — plunge down one branch fully before backtracking. Memory-light, but it can get lost down a deep wrong path and isn't guaranteed to find the best solution.

Add path costs and BFS generalises to Uniform-Cost Search, which always expands the cheapest-so-far node and is guaranteed to find the lowest-cost path. The trouble with all of these is they ignore any sense of which way the goal lies — so they explore a lot of pointless territory. That's exactly what heuristics fix.

Informed search and A*

Informed search uses a heuristic $h(n)$ — a cheap estimate of the remaining cost from a node to the goal (e.g. straight-line distance when you're routing through roads). A good heuristic points the search roughly the right way and prunes enormous amounts of wasted work.

The famous A* algorithm combines the cost already paid with the estimate of what's left, expanding whichever node minimises:

f(n) = \underbrace{g(n)}_{\text{cost so far}} + \underbrace{h(n)}_{\text{estimated cost to goal}}

g(n): cost so far. h(n): estimated cost remaining. A* expands the node with the smallest total f(n).

A* is provably optimal — guaranteed to find the cheapest path — as long as the heuristic is admissible, meaning it never overestimates the true remaining cost:

h(n) \le h^{*}(n) \quad \text{for every node } n

The intuition: an optimistic estimate never lets A* wrongly skip the genuine best path. This single algorithm powers route planners, game pathfinding, and countless schedulers — it's the most-used result in classical AI.

A* expansion. From the start, each frontier node is scored f = g + h; A* always expands the lowest f. The optimistic heuristic steers it toward the goal, skipping the branches that can't beat the best path found.

Games: minimax

Games add an opponent who's working against you, so you can't just find a path — you must plan against a rational adversary. The classic answer is minimax: assume both players play perfectly, then pick the move that maximises your outcome given that the opponent will minimise it. You explore the game tree to some depth, score the leaf positions, and propagate values back up — taking the max on your turns and the min on theirs:

\text{minimax}(s) = \begin{cases} \text{utility}(s) & \text{if } s \text{ is terminal} \\ \max_{a}\ \text{minimax}(\text{child}) & \text{if it's our move} \\ \min_{a}\ \text{minimax}(\text{child}) & \text{if it's their move} \end{cases}

Game trees are astronomically large, so minimax is paired with alpha-beta pruning: as you search, you track the best score each player is already guaranteed, and the moment a branch can't possibly beat that, you stop exploring it. It returns the exact same answer as plain minimax while skipping huge swathes of the tree — and it's why classical game AI (chess engines before deep learning) could look many moves ahead.

Constraint satisfaction

Many real problems aren't about finding a path but about finding an assignment that satisfies a set of rules — scheduling exams so none clash, colouring a map so no two neighbours match, solving a Sudoku. These are constraint satisfaction problems (CSPs): a set of variables, each with a domain of possible values, plus constraints saying which combinations are allowed.

You solve them with smart backtracking — assign a variable, check the constraints, and back up the moment you hit a dead end — sped up by constraint propagation, which prunes impossible values from other variables' domains before you even try them. CSPs are a beautifully general hammer: a surprising number of real planning and allocation problems are just a CSP wearing a costume.

Logic and knowledge

The other pillar of symbolic AI is representing knowledge so a machine can reason with it. Propositional logic deals in true/false facts joined by connectives (and, or, not, implies); given some facts and rules, inference mechanically derives new facts that must also be true. "It's raining" plus "if raining then the ground is wet" entails "the ground is wet" — and a machine can prove that step by step.

Propositional logic is limited — it can't talk about objects and relationships in general. First-order logic adds variables, quantifiers ("for all", "there exists"), and predicates, so you can state "every person has a mother" once rather than listing it for everyone. This is the basis of knowledge representation, expert systems, and the knowledge graphs that still underpin search engines and structured reasoning today.

Planning and agents

Planning ties search and logic together: given a start state, a goal, and a set of actions (each with preconditions and effects), find the sequence of actions that reaches the goal. It's search through a space of world-states, guided by logical descriptions of what each action does — how a robot decides the order to stack blocks, or a logistics system sequences deliveries.

The unifying frame for the whole field is the intelligent agent loop: perceive the environment, decide on an action (using any of search, logic, planning, or a learned model), act, and repeat as the world responds.

The agent loop. An agent senses the environment, reasons to choose an action, acts on the world, and perceives the result — the cycle that frames every AI technique, classical or learned.

Where it shows up in my work

Refresh in 60 seconds

Classical (symbolic) AI = reasoning by search, logic, and planning; the rational agent (perceive → decide → act) frames it all.
Many problems = search over states. Uninformed: BFS (shallowest, memory-heavy), DFS (light, not optimal), UCS (cheapest path).
Informed search uses a heuristic. A* expands min $f(n)=g(n)+h(n)$ ; optimal when $h$ is admissible (never overestimates).
Games: minimax (max on your turn, min on theirs) + alpha-beta pruning for the same answer, far less work.
CSPs (assign values under constraints) → backtracking + constraint propagation. Logic (propositional → first-order) represents knowledge and infers new facts.
Modern AI keeps the agent loop and swaps the "decide" box for a learned model — the best systems combine search and ML.