Knowledge Representation

A category like Car can be represented in two different ways. The simplest is as a unary predicate, Car(x), true of exactly those objects that are cars. A more powerful alternative is to reify the category itself — to treat Car as an object in its own right, related to its individual members by a MemberOf relation and to more general categories by a SubclassOf relation. Reification matters because it lets a system make statements about the category itself, not only about its instances: a system can assert that the category Car has many members, or that cars are typically four-wheeled, without those statements being claims about any one specific car. This is the same move made throughout knowledge representation — treating something that could be left implicit in the logic (a category, an event, a time) as an explicit object that relations can be stated about — and it recurs across every subtopic in this module.

Subclass hierarchies built from SubclassOf relations support inheritance: a property asserted of a superclass is, by default, inherited by every subclass and every instance beneath it, unless a more specific statement overrides it for a particular subclass or instance — a Sedan inherits "has four wheels" from Car unless some subclass of Sedan is explicitly declared to be an exception. A separate relation, PartOf, captures physical composition rather than category membership: a wheel is PartOf a car, but a wheel is not a kind of car, and a car is not a kind of wheel either, so the two hierarchies encode entirely different facts about the world. PartOf hierarchies and SubclassOf hierarchies are structurally similar in that both form directed hierarchies that a diagram can draw the same way, but they license entirely different inferences — properties inherit down a SubclassOf hierarchy, while nothing about a whole's properties automatically transfers to its parts, or vice versa — and conflating the two relations is a common and consequential representational error.

Precisely defining a category by necessary and sufficient conditions is often harder than it looks: natural categories like "chair" or "bird" resist crisp logical definitions because real members vary along dimensions the definition would need to anticipate in advance, and edge cases — a beanbag chair with no legs, a flightless bird such as a penguin — routinely violate whatever clean rule seemed to capture the category when it was first written down. Trying to patch the definition with more and more conditions to handle each new exception tends to produce an increasingly brittle, ad hoc list rather than a genuinely general definition. In practice, systems often fall back on typical or default properties with explicit exceptions — "birds typically fly, except for penguins, ostriches, and a known list of others" — rather than insisting on strict necessary-and-sufficient definitions for every category. This is a tension that reappears, and is resolved rather differently, when ontology engineering imposes formal, description-logic-based definitions on categories in the module that follows this one.

John McCarthy and Patrick Hayes's 1969 paper introduced the situation calculus as a formal way to represent actions and their effects within first-order logic. A situation is defined as the complete state of the universe at an instant of time, and a function maps an action performed in a situation to the new situation that results from performing it — so that a sequence of actions corresponds to a chain of situations, and reasoning about whether a plan achieves some goal becomes reasoning about whether the situation reached at the end of the chain satisfies that goal. Properties that can change from situation to situation, such as a door's being open, are represented as fluents, predicates that take a situation as one of their arguments so that their truth can differ across the chain rather than being fixed once and for all. This framework let the authors formalize how actions can be combined into strategies using program-like notation, including loops and knowledge-acquisition steps, and prove things about whether a given strategy is guaranteed to succeed, treating planning itself as a form of logical proof within the same formal system used to represent the facts.

The same paper identified what became known as the frame problem: when reasoning about a sequence of actions, a system must know which facts stay the same across each action as well as which facts change, and naively writing an explicit "this fact did not change" sentence for every fluent and every action produces roughly (number of actions) × (number of fluents) sentences — a combinatorial explosion for any domain with more than a handful of actions and properties, and one that only grows worse as a plan lengthens into a longer chain of situations. McCarthy and Hayes proposed a frame-based shortcut in response: declare which fluents an action changes, and let every fluent not mentioned be presumed to persist unchanged by default, avoiding the need to state persistence explicitly for everything the action does not touch. This shortcut trades a fully explicit, exhaustively stated theory of change for a much smaller one that relies on an implicit default assumption, at the cost of needing extra care whenever that default assumption turns out to be wrong for a particular action.

Later formalisms, including the event calculus and various interval- and point-based temporal representations, extend and in some cases replace situation calculus's discrete before/after structure with explicit representations of time intervals, addressing questions like whether one event happened during, before, entirely after, or overlapping another — distinctions a purely sequential chain of situations does not naturally express. Representing events explicitly, rather than only as the transitions between situations, also makes it easier to talk about an event's duration, about several events happening concurrently, and about reasoning that refers to time itself as an object, such as "the meeting was scheduled for an hour after the previous one ended." This remains an active area of research with multiple competing formalizations rather than one universally agreed solution, particularly once concurrent actions, continuous processes, and events whose exact timing is only partially known are taken into account, and different systems in practice choose different tradeoffs between how much they can expressively represent and how tractable it remains to reason within the chosen formalism.

Many practical spatial-reasoning tasks depend only on qualitative relationships between regions — containment, adjacency, overlap, connection — rather than on precise numeric coordinates: knowing that the printer is in the same room as the desk, or that the desk is next to the window, is often exactly the information a system needs, without ever computing exact positions in a coordinate system or measuring distances. Representing space qualitatively, as a set of regions and topological relations among them, lets a system reason about location and containment using the same kind of logical inference used elsewhere in the knowledge base — the same style of rule-based deduction covered in the automated reasoning module — rather than requiring numeric geometric computation for every spatial question. This mirrors the choice made for time: just as situation calculus can reason about before-and-after ordering without always needing precise clock times, qualitative spatial representations can reason about containment and adjacency without needing precise coordinates, falling back on numeric geometry only when a task genuinely requires it.

Belief poses a different and subtler challenge. Representing "Priya believes the printer has been fixed" is not the same problem as representing "the printer has been fixed," because the belief report can be true even when the sentence believed is false. Philosophers analyzing propositional attitude reports — sentences describing an agent's cognitive relation to a proposition, such as belief or knowledge — have identified this as a case of referential opacity: inside an ordinary sentence, substituting one term for another term that refers to exactly the same thing never changes the sentence's truth value, but inside a belief context, that substitution can change the truth value, because an agent can believe something true of one name for a thing while not believing the same thing is true of another, equally correct name for it. The classic illustration involves someone who believes Superman can fly without believing that Clark Kent can fly, even though Superman and Clark Kent are, as a matter of fact, the very same person — the belief report is sensitive to which name was used, not only to which individual is actually being referred to.

The practical consequence for knowledge representation is that inference rules safe for ordinary first-order sentences — such as substituting equals for equals, or existentially generalizing from a specific individual to "there exists someone such that..." — become unsafe once they are applied inside a belief context, so systems typically represent beliefs either through a dedicated modal-style operator, Believes(Agent, Sentence), or by treating the believed sentence as quoted content rather than as directly asserted by the system itself. Keeping "what is true" and "what an agent believes is true" as separate, distinctly represented layers is essential for any system that reasons about other agents — other people, other AI systems, or even its own possibly outdated beliefs about the world — since collapsing the two layers into one would force the system to treat every belief it represents as simply true, making it unable to reason correctly about mistaken, outdated, or deliberately false beliefs held by the agents around it.