Most of this track is about machines that learn — that soak up patterns from data. This course is about the other half of artificial intelligence, the older half: machines that know. Knowledge representation (KR) is the study of how to encode facts, rules, and meaning in a form a computer can store, query, and — crucially — reason over. It is how a system can be told that a dog is a mammal and work out, on its own, that a dog therefore breathes air.
- Understand the difference between data, information, and knowledge
- See the main ways to represent knowledge — networks, frames, rules, logic, ontologies
- Follow how logic lets a machine infer facts nobody stored directly
- Recognise KR in real systems, and how it now teams up with LLMs
From data to knowledge
Not everything a computer stores is knowledge. There is a ladder worth keeping in your head:
DATA "37.8" a raw symbol, no meaning
│
▼
INFORMATION "body temp = 37.8°C" data with context
│
▼
KNOWLEDGE "37.8°C is a normal facts + rules that
human temperature; connect to other facts
above 38°C = fever"
A knowledge representation always has two halves that work together: a way to write down what is true (the representation), and a way to derive new truths from it (the reasoning). One without the other is useless — a filing cabinet with no clerk, or a clerk with no files.
Here is that second half — reasoning — made visible. Below is an everyday piece of knowledge drawn as a map: things connected by relationships. Follow an arrow and you are doing exactly what a knowledge-based machine does — deriving something new from something you already knew (it's raining → the roads are wet → expect traffic). Drag the nodes to explore it, and reload the page (or tap another example) to get a fresh one.
When it rains…
This is one of the oldest ideas in human thought, not a computing invention. Aristotle, 2,300 years ago, built the first formal KR system: categories to classify things and syllogisms to reason about them. "All men are mortal; Socrates is a man; therefore Socrates is mortal" is a knowledge representation and an inference engine in one sentence. Leibniz later dreamed of a calculus ratiocinator — a universal symbolic language in which disputes could be settled by calculation. AI inherited the dream and gave it a keyboard.
- Knowledge is data plus the context and rules that connect it to other facts
- Every KR has two halves: a representation, and a way to reason over it
- The idea is ancient — Aristotle's categories and syllogisms were the first KR
The ways to say what you know
Over the decades, a handful of representation schemes emerged. They are different notations for the same goal — capturing things and how they relate. Here is one fact — a canary is a bird that can sing and fly — shown three ways:
SEMANTIC NETWORK FRAME PRODUCTION RULE
(a web of links) (a labelled record) (an if–then)
[Animal] Canary IF x is a Bird
▲ is-a ├─ is-a: Bird THEN x can fly
[Bird] ──can──►[Fly] ├─ colour: yellow AND x has feathers
▲ is-a ├─ can: sing, fly
[Canary] └─ colour inherited? no
Each scheme has a personality:
| Scheme | Good at | Used in |
|---|---|---|
| Semantic networks | showing connections, inheritance | early AI, today's knowledge graphs |
| Frames | describing an object's attributes | object modelling, expert systems |
| Production rules | if–then expertise, procedures | expert systems, business logic |
| Logic | precise, provable statements | formal reasoning, verification |
| Ontologies | shared, formal vocabularies | the Semantic Web, biology, medicine |
- The same knowledge can be written as a network, a frame, a rule, or logic
- Networks show connections; frames show attributes; rules capture if–then expertise
- Good representation lets a machine inherit and derive facts it was never told
Logic: the precise backbone
When you need knowledge that is provably correct, you reach for logic. First-order logic lets you write facts and rules with real precision:
RULE ∀x ( Human(x) → Mortal(x) ) "every human is mortal"
FACT Human(Socrates) "Socrates is a human"
───────────────────────────────────────
INFER Mortal(Socrates) derived, never stored
That last step — modus ponens — is a rule of inference: given "A implies B" and "A," a machine may conclude "B." Chain thousands of these and a computer can prove conclusions no human wrote down. This is the engine behind an ontology — a rigorously defined vocabulary. The web has a standard for exactly this: OWL (the Web Ontology Language), built on description logics, so that "a Parent is a Person with at least one child" is a statement a machine can check and reason with.
- Logic represents knowledge as precise statements a machine can prove over
- Inference rules like modus ponens derive new, guaranteed-correct facts
- Ontologies (e.g. OWL) are formal vocabularies that power rigorous reasoning
- The cost: knowledge must be hand-authored, and the world resists tidy rules
KR in the wild — and the comeback
Knowledge representation is not a museum piece; it runs quietly under systems you use:
- Expert systems — MYCIN (1970s) diagnosed blood infections from ~600 if–then rules, at times outperforming junior doctors. Rule-based systems still run credit decisions, tax software, and configurators.
- Cyc — a decades-long project to hand-encode millions of pieces of human common sense ("you can't be in two places at once"), tackling the knowledge nobody bothers to write down.
- WordNet & ontologies — lexical and domain knowledge that structures search and biology; the Gene Ontology lets researchers reason across species.
- The Google Knowledge Graph — the panel on the right of your search results is a giant KR, answering "who directed the film that won…" by following links.
Which is exactly where you head next. The Knowledge Graphs course takes the network idea from this course and scales it to millions of facts — the practical, modern face of knowledge representation, and one of the best ways to keep an LLM honest.
- KR powers expert systems, common-sense projects, ontologies, and search panels
- Its strength — exact, checkable facts — is precisely the LLM's weakness
- Neuro-symbolic AI combines learned patterns with represented knowledge
- Knowledge graphs are the modern, scaled form of these ideas
- A system stores "a penguin is a bird" and "a bird has feathers," but not "a penguin has feathers." How can it still answer that a penguin has feathers?
- Give one strength of logic-based KR and one strength of machine learning, and explain why a system might want both.