Why Can't Computers Think Like You? The Logic That Breaks the Rules
A plan that survives a meteor strike
You need to get to the airport. You picture the route: walk to the bus stop, take the 42 bus, then the train. Done. You don’t consider that an earthquake might swallow the road, or a meteor could land on the train. You don’t even worry about traffic jams unless someone warns you. In a few seconds, your mind ignores most of the universe, trusts that things will stay the same, and settles on a plan.
This kind of everyday thinking is so natural that we barely notice it. But for a computer, it’s a nightmare. A machine programmed with the rules of strict logic would have to check every possible disaster before concluding anything — and there are billions. The story of how artificial intelligence researchers tried to give computers this flexible, jump-to-conclusions kind of reasoning is a wild ride through broken rules, stubborn turkeys, and a puzzle that changed logic forever.
When logic is too logical
For centuries, logic was the study of perfect, airtight reasoning. Mathematicians built systems where if you start with true statements and follow the rules, your conclusion is guaranteed. Most importantly, these systems are monotonic: adding new information never removes a conclusion you already proved. If you know that “All birds fly” and “Tweety is a bird,” you can prove “Tweety flies.” Learning that “Tweety is yellow” won’t change that proof.
Classical logic was designed for mathematics, and it works beautifully there. But everyday life isn’t monotonic. You walk into the kitchen, smell brownies baking, and conclude your sister made brownies. Then you hear her voice on a phone call in the other room, and you immediately abandon your conclusion — maybe your dad baked. Your reasoning retracts an earlier claim. That’s nonmonotonic: the reasoning backs up when new evidence arrives.
Computer scientist John McCarthy saw this problem in the 1950s. He believed that if we ever wanted a machine with real common sense, we’d need a logic that could make educated guesses, assume things were normal unless proven otherwise, and gracefully change its mind. That vision sparked a decades-long quest for nonmonotonic logic.
Defaults and the art of guessing safely
Think about how you reason about a party. You assume your friend Sam will come, because Sam always comes. That’s a default rule: in the absence of information that Sam is sick or away, you conclude Sam will be there. The rule isn’t a guarantee — it’s a bet that works most of the time. You might write it as: If nothing blocks it, conclude Sam is coming. If later you hear Sam has the flu, you withdraw the conclusion.
In the 1980s, researchers like Ray Reiter, Drew McDermott, and Jon Doyle turned this idea into formal systems. Reiter’s default logic allowed a machine to store two things: plain facts (like “penguins are birds”) and default rules (like “typically, birds fly”). When the machine needed an answer, it would apply defaults unless they conflicted with something else it knew. That gave it flexibility — the logic didn’t have to list every exception in advance.
Crucially, a default theory could produce multiple different extensions, each a consistent picture of the world. With the same facts, one extension might conclude Sam is coming, while another (triggered by learning Sam is sick) would conclude Sam is absent. This was a huge shock to logicians: a set of premises didn’t lock you into one outcome. Reasoning was no longer a single path; it was a branching tree of possible, coherent stories.
The frame problem and the stubborn turkey
One of the hardest parts of everyday reasoning is knowing what doesn’t change when you act. You pack a lunch, and you assume your backpack doesn’t spontaneously turn into a pumpkin. Planning a trip to the airport relies on inertia: things stay the same unless an action specifically changes them. This is the frame problem, named by McCarthy and Patrick Hayes in 1969.
A nonmonotonic solution seemed obvious: treat inertia as a default. Just assume any fact remains unchanged, unless there’s a special reason to change it. But a clever test scenario — the Yale Shooting Anomaly — showed that this approach could go embarrassingly wrong.
Imagine a story with a turkey named Fred, a pistol, and three actions: load, wait, and shoot. Loading makes the gun loaded. Shooting only works if the gun is loaded, and it makes Fred not-alive. Waiting does nothing. Start with the gun unloaded and Fred alive. Now perform the sequence: load; wait; shoot. Common sense says Fred ends up dead. But a naive version of default logic allowed an alternative outcome: during the wait step, the gun somehow became unloaded (inertia was violated for the gun), and then shooting had no effect, so Fred remained alive. Both the expected story and this weird one violated exactly one default — so the logic saw both as equally reasonable. That’s a crisis for any planning program.
The Yale Shooting Anomaly showed that you can’t just count on defaults; you need a deeper story about why changes happen. Computer scientists spent years trying to tame the frame problem.
Causes: the hidden engine of change
A breakthrough came from thinking about causes. In the weird shooting story, the gun unloading for no reason is uncaused. In our real world, events don’t just happen — they have causes. Hudson Turner and others built formal systems where a special operator, Caused, marked which facts were forced by an action or a law of the domain. In a correct model, everything true must be caused, either as the direct effect of an action, as an indirect ramification, or by inertia preserving a caused fact.
Turner’s approach used nonmonotonic logic to select preferred models — pictures of the world where nothing magical occurs. In the shooting story, the model where the gun unloads by itself fails because that unloading isn’t caused by anything. So it gets rejected. Fred meets his (logically) expected fate. Causal theories gave a clean, philosophically satisfying answer that also worked for harder puzzles, like why starting a car doesn’t kill the battery just because a static law says “if ignition on and engine not running, battery dead.”
This “principle of universal causality” — that every truth has a cause — turned out to be a powerful tool for both reasoning about robots and for understanding how humans make predictions.
The common sense that still outruns us
Even with causal logic, machines remain far from your everyday cleverness. Formalizing a simple task like cracking an egg into a bowl — as proposed by computer scientist Ernest Davis — forces you to write axioms about eggshells, force, gravity, and fragile materials. And that’s just for the normal case. What if the bowl is made of soft clay? What if you try with a coconut? The list of variations explodes.
The quest for a logic of common sense has produced incredible tools, from robot planning to databases that answer questions intelligently. But it has also revealed how much of our thinking is invisible to us, layered with assumptions about space, time, minds, and social rules. This isn’t a failure of logic; it’s a challenge that philosophers and computer scientists now share: mapping the architecture of the everyday reasoning that makes you human.
Think about it
- If a self-driving car uses default rules to ignore unlikely dangers (like a piano falling from the sky), who is responsible when something truly rare happens? Is it okay to ignore some possibilities?
- Suppose a robot learns your daily schedule and correctly predicts when you’ll want a snack. Does it understand you, or is it just using statistics? What’s the difference between predicting and understanding?
- Think of a time you changed your mind because of new information. Could a machine ever be as flexible as you were, or does changing your mind require something logic can’t capture?
