Can “Some” Ever Be Free of “All”?

The 1800s Puzzle: When One Number Depends on Another

In the 1860s, a meticulous German mathematician named Karl Weierstrass (1815–1897) set out to clean up a messy problem: what does it really mean for a line to be unbroken, for a curve to be continuous? He wanted a definition with zero hand-waving.

Weierstrass’s answer turned into the famous “epsilon‑delta” definition. It says, roughly: a curve is continuous at a point (a) if, for every tiny challenge number (\varepsilon) you pick, I can find a response number (\delta) — and here’s the catch — the (\delta) must work for that particular (a), but might need to change if (a) changes. In a stricter version called uniform continuity, the (\delta) does not depend on (a) at all; it depends only on (\varepsilon).

At the heart of Weierstrass’s work sits a simple pattern: one quantity depends on another, but not on a third. Ordinary logic — the kind you use when you say “every dog has a tail” or “some bird can’t fly” — isn’t built to mark that kind of independence clearly. The words “for all” and “there exists” (logicians call them quantifiers) each have a fixed scope, like a zone of control. If an “exists” falls inside the zone of an “all,” the two are automatically linked.

Jaakko Hintikka (1929–2015), a Finnish philosopher‑logician, thought that was a mistake. He wanted a logic where you could draw a line right through a sentence and say: this “some” depends on this “all,” but not on that one.

Logic as a Game: Hintikka’s Big Idea

To make dependence visible, Hintikka stopped treating logic as a set of dry formulas. He imagined it as a two‑player game.

Think of a game board. The sentence is the playing field. One player (let’s call her Verifier) wants to show the sentence is true. The other player ( Falsifier ) wants to prove it false. The players take turns picking objects from the world you’re talking about.

• When the sentence says “for all (x),” Falsifier must pick a specific (x) — any one he likes — to try to make the rest of the claim collapse.
• When the sentence says “there exists (y),” Verifier must pick a (y) that keeps the rest of the claim standing.

If Verifier has a winning strategy — a set of rules that guarantees she’ll win no matter what Falsifier does — then the sentence counts as true. If Falsifier has a winning strategy, the sentence is false. A strategy is like a recipe: “If Falsifier chose apple, I will choose banana; if he chose cherry, I will choose date.” Those recipes are called Skolem functions (after Thoralf Skolem, 1887–1963). A Skolem function spells out exactly which earlier choices a “there exists” move is allowed to look at.

Branching Choices: When Quantifiers Go Independent

Now the exciting part. What if Verifier’s move for one “there exists” must be made without seeing a particular earlier choice by Falsifier? In regular logic, every “exists” inside the scope of an “all” automatically knows that “all.” Hintikka added a slash to break that link.

You write ((\exists y / \forall x)) to mean “there exists a (y) that does not depend on the choice made for (x).” The slash is an independence indicator. In the game, Verifier literally cannot use the value of (x) when she picks (y). She must pick the same (y) regardless of what (x) turns out to be.

This lets you build sentences that ordinary first‑order logic simply cannot say. The most famous pattern is a Henkin quantifier, named after Leon Henkin (1921–2006), who first drew it as a two‑dimensional block:

[ \begin{matrix} \forall x , \exists y \ \forall z , \exists w \end{matrix} R(x, y, z, w) ]

Here, the witness for (y) may depend on (x) but not on (z) or (w); the witness for (w) may depend on (z) but not on (x) or (y). No re‑arrangement of the quantifiers in a single line captures that pattern. With IF logic (as Hintikka called it), you can write such branching in a one‑line formula: ((\forall x)(\exists y)(\forall z)(\exists w / \forall x) R(x, y, z, w)). The slash on (\exists w) says: ignore the move for (\forall x).

The result is a logic that can say “there are infinitely many things,” “this graph is disconnected,” or “these two sets have the same size” — all ideas that pure first‑order logic cannot express.

A Logic that Breaks Its Own Rules

When you give players imperfect information, the safe, familiar properties of logic start to wobble.

First, some sentences become non‑determined: neither player has a winning strategy. The sentence is not true and not false. For example, on a world with exactly two objects, the IF‑sentence ((\forall x)(\exists y / \forall x) , x = y) is undecided. Falsifier can’t force a loss, but Verifier can’t force a win either. The law of excluded middle — “either a claim or its opposite is true” — no longer holds for the game‑theoretic negation.

Second, the logic cannot be reduced to a tidy set of mechanical rules for checking all valid arguments. IF logic is not axiomatizable; there is no finite list of proof steps that will catch every logical truth. Some philosophers, like Willard Van Orman Quine (1908–2000), argued that any logic without a complete proof system isn’t really logic at all — it’s mathematics in disguise. Hintikka replied that understanding a sentence means knowing what the world must be like for it to be true, not having a machine that lists its logical relatives.

Third, IF logic resists compositionality — the idea that the meaning of a whole sentence is built purely from the meanings of its pieces. In IF logic, a quantifier’s meaning can depend on its relationship to quantifiers nowhere near it inside the formula. A logician named Wilfrid Hodges (1941–) later found a clever compositional semantics using teams of assignments instead of single ones, but the simplest picture of meaning — a single variable assignment at a time — doesn’t work.

What This Means for Truth and Real Language

Hintikka believed IF logic isn’t just a toy. For him, it reveals something deep about truth itself.

Because IF logic can talk about its own strategies, it can construct a self‑applied truth predicate: a sentence that says, inside the same language, “This very sentence is true in the standard model of arithmetic.” In ordinary first‑order logic, Alfred Tarski (1901–1983) proved that’s impossible without creating paradoxes. IF logic gets around the obstacle because its game‑theoretic negation is weaker than the “contradictory negation” Tarski assumed. (Strong negation switches roles in the game; weak negation simply says “no winning strategy exists.”)

Hintikka also thought IF logic might reconstruct all of ordinary mathematics without ever talking about “the set of all subsets” — a notion that has caused endless headaches in set theory. Whether that claim holds up is hotly disputed, but it pushes philosophers to ask what we really commit to when we do math.

And natural languages, Hintikka noticed, are full of independence. Take the English sentence:

Some relative of each villager and some relative of each townsman hate each other.

Under one natural reading, the relative you pick for each townsman can be chosen without knowing which villager was picked. That’s a Henkin‑style branching. Or think of questions like “Who does everybody admire?” where the answer — a function like “their father” — depends on the person but not on what the questioner happens to know. IF logic, with its slash notation, offers a way to write such readings down precisely.

Why It Still Matters: The Game of Computation

You might wonder whether a logic where some sentences are neither true nor false is just a curiosity. It turns out to sit at the edge of one of the biggest unsolved problems in computer science.

Deciding whether an IF sentence is true on a finite model can be exactly as hard as the famous P vs. NP question: can every problem whose solution is quick to check also be quick to find? If IF logic were closed under weak negation on finite models — that is, if for every IF sentence we could build another that says exactly its contrary — then NP would equal co‑NP, a result that would shake the foundations of computing. Nobody knows the answer.

So the independence that Weierstrass quietly encoded in an epsilon‑delta definition has grown into a logic that ties together the nature of truth, the limits of proof, and the hardest puzzles about what machines can do. The next time you play a game where you have to keep some information hidden from yourself, you’re walking on ground that logicians are still mapping.

Think about it

1. If a sentence in a game can be neither true nor false, could it still be useful? What real‑life questions might work that way?
2. Can you think of a situation where someone’s choice should be truly independent of a piece of information, even though that information is known to others?
3. Suppose a computer using IF logic could solve every problem that today’s computers find hard. Would that change what you trust a machine to decide?