PREDICATE LOGIC I:

Being a Set of Supplementary Note on Predicate Logic, to accompany Allen/Hand, Logic Primer

Names, Predicate Expressions, and Simple Predications

Sentential logic is really the theory of the sentential connectives. Compound sentences are built up from other sentences (and ultimately from atomic sentences) by combining them with connectives. Each primitive rule of inference concerns one of the connectives and gives a rule for inferring a new sentence in which that connective has been either added or deleted. Truth tables for sentences and arguments are constructed using the basic truth table definitions for the connectives.

So, from the standpoint of sentential logic, atomic statements are really atomic, that is, indivisible (that's what the word 'atomic' originally meant). Sentential logic can't see any structure inside atomic statements. From this standpoint, all that an atomic statement is is a bearer of a truth value: there's nothing more that sentential logic can say about the meaning of an atomic statement.

What makes this significant for logic is that some arguments composed entirely of atomic sentences, from the standpoint of sentential logic, are still clearly valid. For instance:

Rover is a dog

All dogs are carnivores

Therefore, Rover is a carnivore

This is obviously valid. However, if we translate it into the language of sentential logic, it becomes:

P, Q |- R

And this is, equally obviously, an invalid sequent. What's wrong?

The problem is simply that our system of sentential logic can only catch part of the story of validity. Some arguments are valid because of the way they are structured with sentential connectives. Sentential logic explains why these are valid. Other arguments, such as our last example, are not valid for that reason, but they are nevertheless valid. Predicate logic is an extension of sentential logic which studies why those additional arguments are valid.

The English sentences that we treat as atomic in sentential logic obviously do have some internal structure. 'John likes mangoes', 'Mary took a long vacation in Flush, Kansas', 'Every single one of the many cockroaches in my kitchen is a disgusting abomination' are all atomic, and so we'd translate them as 'P', 'Q', 'R'; nevertheless, these sentences are clearly built up of smaller parts.

In fact, different atomic sentences can share some of those smaller parts. Consider these examples:

• John likes mangoes
• Mary likes mangoes
• Mary likes manatees
• John likes Mary
• John hates manatees
• Mary hates John

The words 'John', 'Mary', 'likes', 'hates', 'mangoes', 'manatees' appear in different places in these various examples. Our goal in predicate logic is to understand how these combinations are constructed and how their relationships can make an argument valid.

Names and Predicate Expressions

Here are some very simple sentences:

• Fido is a dog
• Rover is a dog
• Piewacket is a cat
• Rover is a Schnauzer
• Snidely was a rat
• Godzilla exploded

These sentences all share a common structure. Each consists of a name, such as 'Fido' or 'Godzilla', combined with a certain kind of phrase. As the examples show, two sentences might combine the same phrase with different names, or the same name with different phrases. We can picture this structure as follows:

The expression '___ is a dog' is an expression with a blank in it. That blank is a place in which a name may be substituted to produce a sentence. We will call expressions like this, with blanks in them where names can be filled in, predicate expressions. A predicate expression is a sentence with a name (or names) that has been replaced by a blank (or blanks) in this way. You might put it this way: a predicate expression is something that becomes a sentence when its blank space (or spaces) is (or are) filled in with names; a name is a word that can be used to fill in a blank in a predicate expression. Finally, the sentence that results when the blank(s) in a predicate expression are filled with names is called a simple predication

As the last paragraph suggests, there are predicate expressions that have more than one blank space. Here are some examples:

• Rover ate Roderick
• Roderick ate Rover
• Fido loves Murgatroyd
• Godzilla will destroy North Zulch
• John knows Marcia
• John knows John
• John knows himself
• John stole Rover from Marcia

The sentence 'Rover chased Fido' contains two names, 'Rover' and 'Fido', and the predicate expression '___ chased ___'. It's important to note that there are two blanks in this expression. As the first two examples illustrate, it makes a difference where each name is substituted for the blank: the ingredients that go into 'Rover ate Roderick' and 'Roderick ate Rover' are the same, but the sentences are very different in meaning.

There are also predicate expressions with three blanks for names. Here are some examples:

1. George introduced Alice to Margaret
2. Achilles dragged Hector around Troy
3. Antony took Cleopatra to Rome
4. Wilfred sat between Winifred and Winston
5. Austin is between San Antonio and Waco

Predicate expressions with four or more blanks are harder to find in a natural langauge like English, but examples do exist:

1. Seven is to three as fourteen is to six
2. Godzilla divided Brooklyn between Gamela and Rodan

Translating Simple Predications

We can expand our symbolic language for logic to accommodate the structures of simple predications. We will need two new classes of symbols, corresponding to the two new types of expression we've introduced (names and predicate expressions).

Table 1: Translating Names and Predicate Expressions

We translate names with lower-case letters from the beginning of the alphabet. Just to make sure we never run out of names, we can add subscripts to these letters as much as we need.

We translate predicate expressions with upper-case letters. As before, we will allow ourselves to add subscripts to get as many as we need. We call these translations of predicate expressions predicate letters.

But this isn't yet quite enough. Each predicate expression has a certain number of blank places in it where names can be substituted. Where are the blanks in our symbolic translations? The answer is that we will adopt the convention that they all occur in a sequence, one after the other, to the right of the letter. (It's perhaps just a little unnatural, but that's the way logicians have got used to doing it in the last century or so.) That still leaves one question unanswered: how do we tell how many blanks go with a given predicate letter? In English, we can identify the blanks in a predicate expression just by looking. However, in our symbolic langauge, we will use a superscript number on a predicate letter to indicate how many blank places go with it. More formally, there are:

We'll suppose that we have predicate letters with any (finite) number of places whatever. Then, we will use a one-place predicate letter to translate a predicate expression with one blank, a two-place predicate letter to translate a predicate expression with two blanks, etc. So,

Table 2: Translating Names and Predicate Expressions (The Whole Story)

In passing, we should note that there are also zero-place predicate letters: these are just the propositional variables we used in sentential logic.

Now we just need to explain how to combine these into translations. For one-place predicates, that's easy: we translate names with names, predicate expressions with predicate letters, and simple predications as a predicate letter followed by a name. Using these translations,

we will get the following:

Sentential Compounds of Simple Predications

We can combine simple predications with sentential connectives, just as we learned to do in studying sentential logic:

As the last of these examples illustrates, when different components of a compound sentence share a name or a predicate expression, we often abbreviate the second occurrence: 'so did Mothra' is short for 'Mothra blew up'. In translating, we always spell out such abbreviations in full:

Many-Place Predicates

In many-place predications (that is, those with more than one place), the different places are not equivalent, as explained above: 'Godzilla ate Brooklyn' and 'Brooklyn ate Godzilla' are not at all the same. We need a way to keep track of this difference in translating. Suppose, for example, that we use the following translations:

How will we know whether 'A²gb' translates 'Godzilla ate Brooklyn' or 'Brooklyn ate Godzilla? We don't, until we decide which of the two places following the predicate letter corresponds to each of the blanks in the predicate expression. The easiest way to do this is to use the letters x, y, z (and others as necessary) to indicate these connections, as in the following example:

What this means is that, in translating '___ ate ___', we will associate the first blank place in the predicate expression with the first place following the predicate letter (note where 'x' occurs) and the second blank place with the second place following the letter (note where 'y' occurs). From now on, these notes will always specify the translation of a predicate expression in this way. Here are some examples:

It's important to note that, in deciding on a translation for a predicate expression, you can assign any order you please to the places following the predicate letter. However, once you've done so, you have to stick with that assignment.

On Superscripts: That They May Be Omitted

We added superscripts to our predicate letters to indicate how many places each one had. That's important in defining a wff in predicate logic: an n-place predicate letter followed by exactly n names is a wff, but if it is followed by more or fewer than n names it's not a wff. However, in translating sentences, we can follow the practice of common among logicians of omitting the superscripts. What we do, in effect, is to assume that every predicate letter we write always has the right number of places filled after it.

Since we're going to do this, it becomes a very good idea not to use two predicate letters in the same translation that look just alike except for their superscripts, e.g. A¹ and A².

There's more about predication here