The Substitutional Account of Logical

Consequence
Advanced Topics in Philosophy of Logic
Jason Turner

According to the Bolzano-style substitutional account of logical consequence,

P is a logical consequence of ∆ if and only if every uniform substitution of
non-logical terms that makes ∆ true also makes P true. In this handout, I go
through just what that means, and then spell out the standard objection from
impoverished languages.

1 Simple and Complex Expressions

Suppose we have a language, L. This language will have in it simple expressions.
These will be the smallest meaningful units of the language.
For instance, our language may be English. Then the simple expressions
will be the words of English. Or it may be propositional logic. Then the simple
expressions will include, e.g.,
∼, ∧, ∨, →, P, Q, R, . . .
Or it may be a first-order language. Then the simple expressions will include,
e.g.,
∼, ∧, ∨, →, ∃, ∀, F, G, R, . . . , a, b, c, . . .
Call the expressions that aren’t simple, complex. Complex expressions can be
of the same syntactic type as simple ones. For instance, in English, the simple
expression
Jason
and the complex expression
the third person from the right
are both of the same syntactic category. You can see this because you can take
any meaningful sentence using ‘Jason’, replace all or some instances of ‘the third
person from the right’, and the result will still be a meaningful sentence.
We can also do similar tricks in formal languages if we’re willing to wrest
with syntax a bit. For instance, if we have simple, one-placed predicates F and
G, the complex of expressions
F(_) ∨ ∼G(_)
counts as the same syntactic type, in the following sense. If we have a meaning-
ful sentence with (for example) F(a) in it, and we replace F(a) with F(a) ∨ ∼G(a)
is a meaningful sentence, too. And of course it doesn’t matter that the name
here was ‘a’; we would have got a meaningful sentence whatever name had
been used.

1
2 Substitution Schemes
If L is a language, let a substitution scheme be a rule for trading simple expres-
sions of L for any expressions at all (simple or complex) of the same syntactic
type. (Formally, we think of these as mappings, or functions.) For instance, if we
have a propositional language with only the following expressions:
∼, ∨, P, Q, R
then these are both examples of substitution schemes (for our language):
Scheme 1
P 7−→ (Q ∨ R)
Q 7−→ R
R 7−→ ∼Q
∼ 7−→ ∼
∨ 7−→ ∨
Scheme 2
P 7−→ ∼∼P
Q 7−→ Q
R 7−→ (R ∨ ∼R)
∼ 7−→ ∼(P ∨ _)
∨ 7−→ ∼_ ∨ _
A substitution scheme is just a mapping from some terms to others. How-
ever, once we have one, we can use it as a recipe for turning sentences of our
languages into other sentences of our languages.
To see how this works, take for an example the sentence
∼P ∨ (Q ∨ R)
If we replace each simple term in this sentence with the thing it is mapped to in
Scheme 1, the sentence becomes
∼(Q ∨ R) ∨ (R ∨ ∼Q)
If we do the replacements specified in Scheme 2, the sentence becomes
∼∼(P ∨ ∼∼P) ∨ (Q ∨ (R ∨ ∼R))
Notice that we only replace the simple expressions of the original sentence —
not ones added by the substitution scheme itself. For instance, if we start with
∼Q and use Scheme 2, that tells us to replace it for ∼(P ∨ Q). This introduces
a new simple term we didn’t have before, namely, P. But we don’t then have to
go and apply Scheme 2 to this newly introduced P.
If S is a replacement scheme and P a sentence, we let S( P) represent the
sentence that we get by taking P and replacing all its simple expressions for
their values according to S. Also, if ∆ is a set of sentences, we let S(∆) represent
the results of applying S to all the sentences in ∆.

2
3 Bolzano’s Account

3.1 The Basic Idea

Since our language is meaningful, its sentences have truth-values. Moreover, it
can happen that a substitution scheme can take a true sentence to a false one,
or vice versa. For instance, if Q is true and R is false, Scheme 1 above will take
a true sentence (Q) to a false one (R).
Bolzano’s basic idea was this: if every substitution scheme that took all of
the sentences of ∆ into true ones also took P into a true one, then P would be a
logical consequence of ∆.
Let’s make this more precise. We’ll do so by providing one technical definition
(so it’s truth isn’t up for grabs — it’s true by definition!) and one hypothesis (so
it’s truth is up for grabs — it’s something we can argue about!)
Here’s the technical definition:

Substitutional Consequence: P is a substitutional consequence of ∆ (∆||= P) iffd f .

for every substitution scheme S: if S(∆) is true, then S( P) is true, too.

And here’s the hypothesis:

Substitutionalism: ∆ ⇒ P iff ∆||= P.

3.2 A Problem
Unfortunately, this won’t work. There are (almost) no substitutional conse-
quences whatsoever on the above definition, and so (if we accept Substitution-
alism) there are almost no logical consequences, either. Consider, for example,
the argument

R∨Q
∼R
Q

This argument (we may think) ought to come out valid. But it doesn’t. Suppose
that R is true and Q is false, and consider the substitution scheme that takes ∼
to ∼∼ and leaves everything else the same. Under this scheme, the argument
becomes

R∨Q
∼∼R
Q

which has true premises and a false conclusion. So the conclusion of the original
argument isn’t a substitutional consequence of the premises, and so it isn’t a
logical consequence of the premises, and so the argument isn’t valid. This is a
bad result.

3
3.3 Fixing the Problem
The problem came because we fiddled with the logical constants. The solution,
intuitively, is to say that only substitution schemes that don’t fiddle with the
logical constants count.
More precisely, we start with a (new) definition of substitutional conse-
quence. Begin with the observation that some substitution schemes take some
simple expressions to themselves. For instance, Scheme 1 took ∼ and ∨ to
themselves, and Scheme 2 took Q to itself.
If E is a set of expressions of the language and S a substitution scheme, say
that S preserves E iff S takes all the expressions of E to themselves.
Next, we define a notion of substitutional consequence relative to a set of ‘fixed’
expressions of the language. If E is a set of simple expressions of the language, then
we have the following definition:

E-Relative Substitutional Consequence: P is a substitutional consequence of ∆

relative to E (∆||= E P) iffd f . for every substitution scheme S that preserves
E: if S(∆) is true, then S( P) is true, too.

Now, here is the (real) idea behind Bolzano’s conception of logical conse-
quence. An argument is valid (i.e., its conclusion follows logically from its
premises) whenever any substitution of the non-logical terms which makes its
premises true also makes its conclusion true. In other words: the conclusion is
a substitutional consequence, relative to the logical terms, of the language.
This then suggests the following refinement of the up-for-grabs thesis:

Substitutionalism: ∆ ⇒ P iff ∆||= E P, where E is the set of logical terms of the

language.

Of course, for this thesis to have any content, there must be a fact of the matter
about whether or not some terms are the logical terms. So whether this account
of logical consequence is even coherent will be held hostage to the project of
discovering which parts of a given language count as its ‘logical terms’.
On the other hand, since substitutional consequence allows for variation rela-
tive to a set of logical terms, Substitutionalism may have an advantage. Consider
the argument

WWI was before WWII.

WWII was before the Vietnam War.
So WWI was before the Vietnam War.

We feel some pull to calling the argument valid, and some pull to calling it
invalid. But, according to substitutionalism, this argument will be valid if and
only if ‘before’ is a logical term. Our indecision about this argument’s validity
will thus be seen as (reasonable!) indecision about whether ‘before’ is a logical
term, and wholly predictable on Bolzano’s account.

4
4 The Overgeneration Problem
Substitutionalism, even now that it’s patched up, has a problem: it predictably
gets the wrong results in certain cases. In particular, it predictably overgenerates
when the language is impoverished.

4.1 Necessity and Sufficiency

Let’s spell out just what this means. Sustitutionalism gives us an analysis, so
it tells us that substitutional consequence is both necessary and sufficient for
genuine logical consequence:

Necessity: If ∆ ⇒ P, then ∆||= P.

Sufficiency: If ∆||= P, then ∆ ⇒ P.

(Strictly, ‘||=’ should be replaced with ‘||= E ’, where E is the set of logical terms
of the language. But from here on out I won’t bother writing this; this is how
| |= should be understood hereafter.) If Necessity is false, then the account
undergenerates: it fails to see genuine logical consequence when it’s really there.
And if Sufficiency is false, the account overgenerates: it sees genuine logical
consequence where there isn’t any.

4.2 Impoverished Languages

The problem for Substitutionalism is that it overgenerates for impoverished lan-
guages. For example, imagine a language L with truth-functional connectives
but no quantifiers, and the following non-logical terms:

f which means Gottlob Frege

r which means Bertrand Russell
L which means was interested in logic

Now consider this argument:

L(f)
L(r)

Both the premise and the conclusion are true. But furthermore, there is no
substitution scheme on this language that will make the premise true and the
conclusion false.
Here’s a little argument to see why. The only predicate-like expressions
of the language have to be truth-functional constructions from ‘L’. But, truth-
functionally, we can only cook up predicate-like expressions that do one of four
things:

(i) Apply only to things that L applies to.

5
 (ii) Apply only to things that L does not apply to. (E.g., ∼ L(_).)
(iii) Apply to everything. (E.g., L(_) ∨ ∼L(_).)
(iv) Apply to nothing. (E.g., L(_) ∧ ∼L(_).)
Since Frege and Russell both satisfy L — they were both interested in logic —
whatever we cook up will of course apply equally well to both of them. So,
no matter what formula F S takes L to, F (r) and F (f ) will have the same truth-
value. And S will have to take each name in the argument either to r or to f, so,
no matter what S does, S(L(f )) and S(L(r)) will have the same truth-value. And
this means that, no matter what S does, the little argument above won’t have a
true premise and a false conclusion.
But, by Sufficiency, this means that the little argument above is valid — that
its conclusion is a logical consequence of its premise. Clearly, though, it’s not
— Russell’s interest in logic is entirely logically independent from Frege’s! So
the account overgenerates.

4.3 Persistence
One way to see that the little argument above is invalid is by considering a
slightly bigger language, L+, that has a new term added, ‘G’, which means
‘natively spoke German’. There are more substitution schemes in this language
than in the old L. In particular, there is the one that takes L to G. So, under
substitution, the above little argument becomes
G(f)
G(r)
which has a true premise and a false conclusion.
This highlights a couple of things. First: whether or not a given function
counts as a substitution scheme is relative to a language. This new function,
which takes L to G, is a substitution scheme relative to L+, but not relative to L,
because G isn’t an expression of L.
Second: an upshot of this is that arguments aren’t valid or not simpliciter, but
only relative to a language. The above little L-using argument is valid relative
to L, but not to L+.
Intuitively, this seems wrong. One and the same argument can be part of
many languages (e.g., of both L and L+), and its validity shouldn’t depend
on what language it happens to be in. This is the principle Etchemendy calls
Preservation: if an argument is valid, it shouldn’t become invalid simply by
expanding the language.
Notice that if our notion of valid-in-a-language didn’t deliver different re-
sults for the same argument relative to different languages, the problem would
go away. We could define genuine consequence as substitutional-consequence-
relative-to-some-language. But if different languages disagree on certain argu-
ments, this won’t work: and this is the violation of Persistence.