Who Sees to It That the Vase Breaks?
A Vase, a Fall, and a Question
Imagine you are holding a vase. Your fingers open, the vase drops, and it smashes into pieces. A grown‑up asks, “Did you drop that on purpose?” But here is the real puzzle: what does it even mean to say you did it? Your hand opened, gravity pulled, the floor was hard. A whole chain of events unfolded. At what point did your action start, and where did the world take over?
For centuries, philosophers have tried to capture this with a special kind of logic—the logic of action. Long before computers existed, the medieval thinker Anselm of Canterbury (11th century) wondered how to talk about deeds with the same precision that mathematicians use for numbers. In the twentieth century, a small army of logicians—including Georg Henrik von Wright (20th century) and Brian F. Chellas (20th century)—gave the question a formal makeover. Today two giant toolkits, stit theory and dynamic logic, help us spell out exactly who sees to it that what happens.
Seeing to It That Something Is True
The star of stit theory is a small but powerful verb phrase: sees to it that. Logicians squeeze it into a symbol: stit, an acronym for “sees to it that.” If i stands for an agent (a person or anything that acts) and φ for a sentence, then stit_i φ means “i sees to it that φ is true.” Suddenly we have a logical language for ownership. To give that language a meaning, Nuel Belnap (20th century) and his colleagues built a picture of time that branches like a tree.
Picture a moment as a thin slice of “now.” Behind it is a single trunk of the past—everything that has already happened. Ahead, the branches split into many possible futures, each one a full history. When you act, you don’t get to pick one single future all by yourself; the world is full of other causes. But your action does chop off some branches. You can make sure that certain futures that were possible before your action are no longer possible after it.
Stit theory adds a choice function that, for each agent and each moment, divides all the histories running through that moment into groups called choice cells. A choice cell lumps together all the futures that are still open given what the agent does. So if history h belongs to a particular cell, everything in that cell shares the same action on the agent’s part. The agent, by acting, forces the future to stay inside one of those cells.
Now we can finally ask: when is stit_i φ true? There are two popular answers, each with its own flavor of “seeing to it.”
Two Flavors of Responsibility
The simpler version is called the Chellas stit (marked cstit). It says cstit_i φ is true at a moment m if, no matter which history inside your choice cell turns out to be the real one, φ comes out true. In other words, your action guaranteed φ. If you flip a light switch and, in every future your flipping allows, the light goes on, then you see to it that the light goes on—in the Chellas sense.
But there is a more demanding version, the deliberative stit (marked dstit). It adds a second requirement: it must not be the case that φ was going to happen no matter what anyone did. There has to be at least one possible future through that moment where φ fails. Otherwise your action didn’t really make the difference; the world was already locked into φ. Think of a teacher who declares “I hereby finish class” at exactly the moment the bell rings. Did the teacher see to it that class ended? The deliberative stit would say no, because the bell would have ended class anyway.
These two operators can be connected with the help of another idea: historical necessity, written as a box □. To say □φ is to say that in every possible future at this moment, φ is true. Then dstit_i φ turns out to be just cstit_i φ with the extra condition that □φ is false—your action guaranteed it, but history alone did not.
Stit theory doesn’t normally talk about actions as separate “things” in the world. It keeps the focus on the relationship between an agent and a proposition. That is a big contrast with the other major tradition, which came from computer science.
Programs That Act
While philosophers were busy planting trees of time, computer scientists were inventing a different logic of action. They needed to verify that programs do what they are supposed to do. Vaughan Pratt (20th century) and David Harel (20th century) turned that practical need into dynamic logic. Its big idea is to treat an action like a computer program that changes the system’s memory. If S is an action (a piece of code), then [S] φ means “after every successful run of S, φ holds.”
This is a modal logic, just like stit theory, but the “possible worlds” are memory states, not moments on a branching tree. A Hoare triple—the classic tool for proving programs correct—says {P} S {Q}: if P is true before S runs, then Q is true afterwards. In dynamic logic that becomes P → [S] Q, a crisp formula you can compute with.
Where stit theory tends to stay quiet about what actions actually are, dynamic logic puts actions right into the language. You can sequence them (S₁ ; S₂), choose between them, and loop them. The induction axiom of Propositional Dynamic Logic says roughly: if doing S once preserves some truth, no matter how many times you repeat S that truth stays around. That idea turns out to be powerful enough to reason about everything from a delivery robot’s route to a character’s moves in a video game.
What Doesn’t Change: The Frame Problem
When you drop a vase, gravity pulls it down. But thousands of other things also happen—or rather, don’t happen. The color of the walls stays the same. The cat on the sofa doesn’t suddenly turn into a pumpkin. Your shoelaces remain tied. Listing every single non‑effect would take forever. This is the frame problem, first named by John McCarthy (20th century) and Patrick Hayes (20th century), and it has haunted the logic of action ever since.
The sheer number of facts that don’t change after an action is immense. If you had to write them all down, you would never finish. So logicians needed a clever shortcut. One popular solution, due to Ray Reiter (20th century), uses a successor state axiom. For each property that might change—called a fluent—you write a single rule that says when it becomes true and when it becomes false. Everything else is assumed to stay the same unless the rule says otherwise.
Take a vase. The fluent “broken” needs a rule: after any action, the vase is broken if (a) that action was a drop and the vase was fragile, or (b) the vase was already broken and the action wasn’t a repair. That one sentence replaces a mountain of “and the vase didn’t turn blue, and the sound didn’t travel to the moon…” This kind of compact representation lets computer scientists build robots that can plan a whole series of moves without drowning in irrelevant details.
Agents That Intend and Commit
In the last few decades, the logic of action has moved from describing single deeds to modeling whole minds. Many researchers now think of an intelligent agent as a system that runs on a blend of beliefs, desires, and intentions—a framework inspired by the philosopher Michael Bratman (born 1945). Bratman argued that humans don’t just slide from desire straight to action. We form intentions that stick with us, shaping our later choices and keeping us on track. If you intend to learn a guitar chord, you won’t abandon it the moment your fingers hurt.
AI researchers have built formal logics to give artificial agents the same sticking power. One approach, called BDI (belief–desire–intention) logic, writes down rules like: “If the agent intends to achieve φ, then it keeps intending until it believes it has succeeded or believes φ is impossible.” That kind of persistence is exactly what stops a robot vacuum from giving up just because the room is messy.
These logics are cousins of the stit and dynamic logic families. The KARO framework, for example, uses dynamic logic to talk about actions such as committing to a plan or dropping a commitment. It even formalizes emotions like joy or regret as patterns of beliefs and goals updating over time. So the same symbolic machinery that started with a monk wondering about acts now helps design machines that can, in a limited way, care about what they do.
Why It Still Matters
The logic of action isn’t just a puzzle for libraries. Every time you ask, “Was that really my fault?” or “Should the robot stop now?” you dip into the very questions these logics are built to handle. When a self‑driving car decides to brake, it relies on a hidden chain of formal reasoning about what its actions guarantee and which futures they close. When a smartphone assistant promises to set a reminder, it is binding itself with something close to an intention. The key ideas—seeing to it that, the frame problem, commitment—show up everywhere humans and machines share a world.
You already live inside that logic. The next time you let a vase fall, you will sense the branching tree of possibilities flicker. And you will know that, for a flash, you and the universe were negotiating which branch becomes history. The question the logicians gave us is simple and deep: who, in the end, sees to it that something really happens?
Think about it
- If a scientist could build a machine that predicts every choice you will ever make, would you still be responsible for breaking a vase? Why or why not?
- Think of a time you weren’t sure whether you “made something happen” or it just occurred on its own. What evidence would you look for to decide?
- Suppose a robot is programmed with a perfect logic of intention and never abandons a goal. Does it have a kind of will, or is it still just following orders?
