The syntax of SL

Use and mention

Most of the time we use words to talk about things. Sometimes we need to talk about the words themselves, and then we mention them. Compare “Boston is in Massachusetts” (about a city) with “‘Boston’ has six letters” (about a name).

The book marks mention in two ways: by putting the expression in single quotes, or by displaying it on its own indented line. You’ll see both throughout this site.

A related pair of terms: when we use one language to talk about another, the language being discussed is the object language and the language doing the talking is the metalanguage. In this course, SL (and later PL) is the object language, and English is the metalanguage.

The vocabulary of SL

Sentence letters are the capital letters A through Z, with or without a positive-integer subscript: A, B, …, Z, A₁, B₁, …, A₂, … That gives infinitely many, which is the point: there’s no limit to how many different claims you might want to symbolize.

The only punctuation marks are the parentheses ‘(’ and ‘)’. A unary connective attaches to one sentence; a binary connective joins two.

Metavariables

To state general rules we need variables that range over sentences of SL, the way a mathematician’s x ranges over numbers. The book uses boldface P, Q, R, S (with subscripts if needed) for this. They are part of English, the metalanguage, not part of SL. Boldface lowercase p, q, r, s play the same role for English sentences.

Watch for this: P & Q is not a sentence of SL. It’s a pattern. A & B, (C ∨ D) & ∼E, and H & H are sentences that fit it.

The recursive definition of “sentence of SL”

1. Every sentence letter is a sentence of SL.
2. If P is a sentence of SL, so is ∼P.
3. If P and Q are sentences of SL, so is (P & Q).
4. If P and Q are sentences of SL, so is (P ∨ Q).
5. If P and Q are sentences of SL, so is (P ⊃ Q).
6. If P and Q are sentences of SL, so is (P ≡ Q).
7. Nothing else is a sentence of SL. (Everything must be built by clauses 1–6.)

How to read it

Think of the definition as a set of building rules, like a recipe that can be repeated.

• Clause 1 gives you the starting pieces. Every sentence letter (A, B, C, …) counts as a sentence, no work needed.
• Clauses 2–6 make new sentences out of ones you already have. Clause 2 takes one sentence and puts a tilde in front. Clauses 3–6 take two sentences, put a connective between them, and wrap the result in parentheses.
• Anything you’ve made can be used again. Once you’ve built ∼C, it’s a sentence, so it can be fed into another clause. That reuse is what makes the definition recursive: the clauses apply to their own results, over and over.
• Clause 7 closes the door. If there’s no way to build a string with clauses 1–6, it isn’t a sentence of SL. This is the closure clause.

The key idea: a string is a sentence of SL exactly when you can show, step by step, how the clauses build it.

A worked example

Let’s show that (A & B) ⊃ ∼C is a sentence. There are two halves to the job: first take the sentence apart to see what it’s made of, then put it together using the clauses.

• Working backward always starts with the main connective: it tells you which clause was used last. You’ll practice finding main connectives later in this section.
• The parentheses on lines 4 and 6 aren’t added by hand. Clauses 3 and 5 put them there. Line 6 ends up with outer parentheses, which the informal convention lets us drop.
• The order of the forward steps is flexible, as long as each sentence is built before it’s used. Line 5 could come before line 4.

Why the parentheses matter

Try to build A & B ∨ C (no inner parentheses). You can’t. If you join A and B first, clause 3 gives (A & B), and joining that with C gives (A & B) ∨ C. If you join B and C first, you get A & (B ∨ C). The parentheses record the order things were built in. They’re how SL avoids the ambiguity English often has.

Step through it

Pick an example and press Next step to see both halves one line at a time.

Which clause came last?

The clause applied last always matches the main connective. A sentence letter needs only clause 1.

Now you build

Build each goal from sentence letters, one clause at a time. Tip: work backward on scratch paper first, then build forward. If you get stuck, press What should I build next?

Is it a sentence?

To test a string, ask whether it could have been built by clauses 1–6. If you get stuck, the place you get stuck tells you why it fails. The common failures:

• A binary connective without a sentence on both sides.
• Two sentences side by side with no binary connective between them.
• More than one binary connective with nothing to show the grouping.
• Parentheses that don’t balance, or that surround a single sentence like (A).
• A symbol that isn’t in SL’s vocabulary, including boldface metavariables.

Informal conventions apply here. The outer parentheses of a sentence may be dropped, and square brackets may replace parentheses. So B & D counts as a sentence.

Main connectives and immediate components

Sentence letters are the atomic sentences of SL. Everything else is a compound sentence and contains at least one connective. Each compound has one main connective, the one added last when the sentence was built, and its scope covers the whole sentence. The main connective decides what type of sentence it is.

A quick way to find it: if the sentence starts with ∼ and that tilde’s scope runs to the very end, the tilde is the main connective. Otherwise, it’s the one binary connective that isn’t inside any parentheses (after outer parentheses are dropped).

Components

The components of a sentence P are P itself, its immediate components, the immediate components of those, and so on down to the sentence letters. Put simply: every sentence you can find inside P, plus P itself.

Type any sentence into the explorer to see its components as a tree, and the order in which the definition builds it.

Two conventions

• Outer parentheses may be dropped. A sentence that begins with ‘(’ and ends with the matching ‘)’ can lose that pair: A ⊃ (B & ∼D) instead of (A ⊃ (B & ∼D)). A negation of a compound has no outer parentheses: it starts with ∼. So ∼(A ∨ B) can’t become ∼A ∨ B.
• Square brackets may replace parentheses to make nesting easier to read: ∼[(A ∨ B) ⊃ (C ≡ D)].