What Is Artificial Intelligence? A Rigorous Introduction

Good morning, everyone, and welcome to the first lecture. Before we write a single line of code or a single equation, we must agree on what we are studying. This sounds trivial. It is not. Researchers have argued about the definition of Artificial Intelligence (AI) for more than seventy years, and the definition you adopt quietly shapes every design decision you will make later.

Four ways to define AI#

In their classic textbook, Russell and Norvig organise definitions of AI along two axes. The first axis asks whether we care about thinking or acting. The second asks whether we measure success against human performance or against an ideal standard of rationality. Crossing the two gives four schools of thought.

1. Thinking humanly. Here AI is a branch of cognitive science. We want programs whose internal steps mirror human mental processes. To validate such a system you need psychological experiments or brain imaging, not just correct answers.
2. Acting humanly. Alan Turing's 1950 proposal: if a machine's conversational behaviour cannot be distinguished from a human's, we should call it intelligent. This view is operational — it ignores what happens inside.
3. Thinking rationally. Descended from Aristotle's syllogisms and modern formal logic. If we can write down correct rules of inference, a machine that follows them thinks "correctly". The difficulty is that most real-world knowledge is uncertain and informal.
4. Acting rationally. An agent is rational if it chooses the action that maximises its expected performance given what it has perceived. This is the definition most modern researchers adopt, because it is mathematically precise and does not require us to copy human quirks.

Why the rational-agent view wins#

Consider a self-driving car. Do we want it to drive like a human? Humans text while driving, get tired and misjudge distances. We want it to drive well — to minimise accidents, travel time and discomfort. The rational-agent view lets us write that goal down as a performance measure and then engineer towards it.

The rational-agent view also unifies the field. A chess engine, a spam filter, a language model and a warehouse robot all look different, but each maps a history of observations to an action:

where $\mathcal{P}^*$ is the set of all percept sequences and $\mathcal{A}$ is the set of actions. The whole of AI can be viewed as the search for good functions $f$ — and machine learning is the branch that learns $f$ from data rather than programming it by hand.

The main subfields#

Artificial Intelligence is an umbrella. Beneath it you will meet the following areas in this course:

• Search and planning — finding sequences of actions that reach a goal.
• Knowledge representation and reasoning — encoding facts and drawing conclusions with logic.
• Reasoning under uncertainty — probability, Bayesian networks and decision theory.
• Machine Learning (ML) — improving performance at a task from experience (data).
• Deep Learning (DL) — machine learning with many-layered neural networks.
• Natural Language Processing (NLP) — understanding and generating human language.
• Computer Vision — understanding images and video.
• Robotics — perception and action in the physical world.
• Reinforcement Learning — learning to act from rewards.

A useful mental picture is a set of nested circles: Deep Learning sits inside Machine Learning, which sits inside Artificial Intelligence. Not all AI is learning (a classical chess engine uses search, not learning), and not all machine learning is deep (a decision tree is not a neural network).

A tiny rational agent in code#

Let us make this concrete. Below is a reflex agent for a two-square vacuum world. It perceives its location and whether the square is dirty, and chooses an action.

def reflex_vacuum_agent(percept):
    """percept = (location, status) where location in {'A','B'}."""
    location, status = percept
    if status == "Dirty":
        return "Suck"
    return "Right" if location == "A" else "Left"

# Simulate a few steps
world = {"A": "Dirty", "B": "Dirty"}
loc = "A"
for step in range(4):
    action = reflex_vacuum_agent((loc, world[loc]))
    print(step, loc, world[loc], "->", action)
    if action == "Suck":
        world[loc] = "Clean"
    else:
        loc = "B" if action == "Right" else "A"

This agent is trivially simple, yet it fits our definition: it perceives, it acts, and its performance can be measured (for example, one point per clean square per time step). Everything else in this course — neural networks, transformers, AlphaZero — is a vastly more sophisticated answer to the same question: given what I have seen, what should I do?

Strong AI, weak AI and hype#

You will hear the phrases weak (narrow) AI — systems that perform a specific task — and strong AI or Artificial General Intelligence (AGI) — systems with flexible, human-level competence across tasks. Every deployed system today, including very large language models, is best understood through careful measurement of what it can and cannot do rather than through labels. As scientists, we measure; we do not merely marvel.