What If Logic Can't Say "It Depends"?

A Love Triangle That Logic Can’t Handle

Imagine three teenagers. The first, a boy named Ben, has a crush on a girl named Grace. Grace doesn’t like Ben back — but she does like another boy, Carlos. And here’s the twist: Carlos is not Ben. In fact, Grace would never like the same boy who likes her.

Now consider this sentence: “Every boy likes some girl who likes some other boy.” In plain English, it just means each boy has his own situation — a girl he likes, and that girl likes a different boy. Ordinary logic can handle this sentence just fine. It uses symbols like ∀ (meaning “for every”) and ∃ (meaning “there exists”) to build a precise map of who depends on whom.

But what if we want to say something slightly different? What if we want to say: “Every boy likes some girl who likes some other boy — and the identity of the second boy does not depend on which first boy we started with.” In other words, if you only know which girl is in the middle, you can figure out who the second boy is, without ever knowing who the first boy was.

Suddenly, ordinary logic is stuck. It cannot express this idea. The dependency is too weird. The second boy depends on the girl, and the girl depends on the first boy — but the second boy does not depend on the first boy. That kind of selective dependence simply cannot be written down in the logic you learn in school.

This is not a trick or a word game. It is a real limit in the most powerful logical system ever invented — first-order logic. And noticing this limit led philosophers and mathematicians to build entirely new kinds of logic.

The Hidden Map of Who Depends on Whom

To understand why ordinary logic gets stuck, you need to see how it builds sentences out of smaller pieces. Every time you use “for every” (∀) and “there exists” (∃), you create a kind of invisible dependency arrow. These arrows point from one variable to another, showing which choices can affect which other choices.

Take the sentence “Every boy likes some girl who likes some other boy.” A logician would write it roughly like this: ∀x (if x is a boy, then ∃y such that y is a girl and x likes y and ∃z such that z is a boy and z is not x and y likes z). Don’t worry about the symbols — focus on what depends on what. The girl y is chosen only after we know who boy x is. That makes sense: different boys might like different girls. Then the second boy z is chosen after we know both x and y. So z depends on both earlier choices.

This creates a chain: z depends on y, y depends on x, and therefore z also depends on x. In first-order logic, dependence is always transitive — it travels along the chain like a relay race. If A depends on B and B depends on C, then A automatically depends on C.

But the sentence we wanted to say breaks this rule. We wanted z to depend on y but not on x. That would be like a relay race where the third runner gets the baton from the second runner, but somehow the first runner’s speed doesn’t affect the outcome. In ordinary logic, that simply cannot happen.

The logician Leon Henkin noticed this problem in 1961. He realized that first-order logic forces all quantifiers (the ∀ and ∃ symbols) to be arranged in a single line, one inside the scope of another. The scopes nest like Russian dolls. But what if you needed your quantifiers to branch — like a tree instead of a single trunk?

When Logicians Bent the Rules

Henkin’s solution was bold. He invented a new kind of quantifier that he wrote as a block, with multiple ∀ and ∃ symbols stacked on top of each other in different “rows.” He called this branching quantifier logic. In this system, you could write something like ∀x ∃y on one row and ∀z ∃w on another, all inside the same big quantifier block.

The idea is that the top row and bottom row are partly independent. The value of w (in the bottom row) does not depend on the values of x and y (from the top row). They belong to different branches. It’s like two separate conversations happening at the same time — what happens in one doesn’t affect the other, even though they’re part of the same overall sentence.

Later, in the 1990s, the logicians Jaakko Hintikka and Gabriel Sandu developed a different approach called independence-friendly logic (or IF logic). Instead of stacking quantifiers into blocks, they kept the usual one-line format but added a new symbol: a slash. When you wrote (∃z / x), it meant “there exists a z, and its value does not depend on x.” The slash explicitly cut the dependency arrow.

Both of these systems could express the tricky boy-girl sentence. They showed that by tinkering with the rules — by allowing quantifiers to branch or by slashing dependencies away — you could say things that first-order logic could never say.

But there was a catch. Both branching quantifier logic and IF logic mixed two jobs together. They used the same symbols (∀ and ∃) both to introduce variables and to specify which variables depended on which. It worked, but it was messy.

Team Semantics: Judging Sentences Together

In the early 2000s, the Finnish logician Jouko Väänänen proposed a cleaner idea. What if, instead of modifying the quantifiers, you added a completely new kind of atomic statement — a dependence atom — that simply says “this variable depends on that one”?

A dependence atom looks like this: =(x₁…xₙ, y). It means “the value of y is completely determined by the values of x₁ through xₙ.” Once you know those x-values, you know y. No mystery, no branching quantifiers, no slashes — just a direct claim about dependence.

Väänänen called his system dependence logic. To make it work, he needed a new way of evaluating whether a sentence is true. In ordinary logic, you check truth one assignment at a time: pick values for all the variables, and see if the sentence holds. But dependence atoms talk about relationships across multiple assignments. So Väänänen borrowed an idea from the logician Wilfrid Hodges, who had developed it in 1997: team semantics.

Here’s the key shift. In ordinary logic (often called Tarski semantics, after the logician Alfred Tarski), you ask: “Does this sentence hold for this one assignment of values?” In team semantics, you ask: “Does this sentence hold for this whole set of assignments?” That set is called a team, and it represents all the possible states of the world that someone believes might be real.

Think of a team as a table where each row is a different possibility. One row might say Ben likes Grace, Grace likes Carlos. Another row might say Dan likes Elena, Elena likes Farid. The dependence atom =(girl, second boy) checks whether, across all rows, knowing the girl is enough to pin down the second boy. If two rows have the same girl but different second boys, the dependence atom is false.

This approach turned out to be remarkably clean. The dependence atom does one job — stating dependencies — while the quantifiers do their old job of introducing variables. And team semantics gave philosophers a new way to think about what it means for a sentence to be true: not just true in one situation, but true across a whole space of possibilities.

One surprising discovery: dependence logic turned out to be exactly as powerful as a fragment of second-order logic — a much more expressive system that allows quantifiers over not just individuals but also sets and functions. Specifically, dependence logic matches the existential fragment of second-order logic (called Σ₁¹). The logician Ronald Fagin had already proved in 1974 that Σ₁¹ captures exactly the problems a computer can check in polynomial time if it’s allowed to make lucky guesses (the complexity class NPTIME). So dependence logic also matches NPTIME — a deep and unexpected connection between logic and computer science.

Why This Still Matters

You might wonder: is this just a clever puzzle for logicians, or does it actually matter outside of philosophy departments?

It matters a lot. Think about a database. A database stores information in tables that look a lot like the teams of team semantics. When a database designer says “employee ID determines salary,” they are making a dependence claim: knowing the ID is enough to know the salary. Database theorists have been studying these functional dependencies for decades. Väänänen’s dependence atoms are essentially the same idea, imported into pure logic. The connection has led to new discoveries in both fields.

Or think about voting. The economist Kenneth Arrow proved in 1950 that no voting system can satisfy three reasonable-sounding rules at the same time: (1) if everyone prefers A to B, the group does too; (2) the group’s ranking of A versus B depends only on how voters rank A versus B, not on their opinions about C; and (3) no single voter is a dictator. Notice how rule (2) is a claim about dependence and independence. In fact, logicians have recently shown that Arrow’s famous theorem can be stated and proved entirely within independence logic. The very dependency patterns that first-order logic struggles with are exactly what you need to understand why fair voting is so hard.

Then there’s quantum physics. Some extensions of team semantics use “quantum teams” where variables can have indeterminate values. In these systems, you can model the strange correlations that show up in quantum experiments — the kind that Einstein called “spooky action at a distance.” The mathematical inequalities that quantum mechanics violates (called Bell’s inequalities) can be studied inside these logics, giving philosophers and physicists a new language for talking about what quantum reality might be like.

And there’s a quieter lesson here too, one that matters even if you never touch a database or a voting booth. Ordinary logic feels like it can say anything. It’s the language of mathematics, of science, of careful thinking. But dependence logic shows us that logic is not finished. There are things worth saying that our usual logical tools cannot express — and when we invent new tools, we sometimes discover that those tools were hiding in plain sight all along, inside databases and voting systems and the paradoxes of quantum particles.

The next time someone tells you that logic is just a bunch of rigid rules, remember: sometimes the rules need to be bent. And sometimes bending them shows you something true that you couldn’t see before.

Think about it

1. Imagine a school where every student is assigned a locker based on their student ID number. The locker depends on the ID. But what if the school also tries to make the locker depend only on the student’s grade level, not on the ID? Can you think of a rule that would make both dependencies true at once, or do they conflict? What would the school have to do?

2. If a database stores your personal information, it uses dependencies — your name determines your date of birth, your address determines your zip code, and so on. What could go wrong if the database designer got one of these dependencies wrong? Can you think of a real-life mess that might result?

3. The article says that in ordinary logic, if A depends on B and B depends on C, then A automatically depends on C. Can you think of a real-life situation where this chain might break — where A depends on B, B depends on C, but A does not depend on C? (Hint: think about friends introducing friends, or recommendations from people you trust.)