This is a talk about predicates and denotational functions. You’ve probably heard a little bit about these in other talks before, but we’ll go into a little more detail than you might have heard before. The talk will be divided into five sections. We’ll start with The Basics.
First off, this is a diagram just to show where the two collections that we’re going to be concerned with figure into a hierarchy – a collection hierarchy – in CycL. As you can see, a #$Predicate is a kind of #$TruthFunction and a #$Function-Denotational, or denotational function, is a kind of #$Relation; a #$TruthFunction is also a kind of #$Relation. So both of these things are specific kinds of relations that are commonly used in the CycL language.
Let’s look at a few basic points about predicates. Here are three instances, or examples, of specific predicates: #$mother, #$objectHasColor, and #$memberStatusOfOrganization. Now, the primary use for predicates is to make sentences.
Let’s see how these particular examples would be used to make sentences.
The first example applies the predicate #$mother to Chelsea Clinton and Hillary Clinton. So the entire expression there is a sentence in CycL which means that Chelsea Clinton’s mother is Hillary Clinton.
The second example uses the second predicate and that sentence means that Rover is tan colored.
Finally, the third sentence applies the third example predicate to the three arguments shown, and it means that Norway is one of the founding members of NATO.
One important feature of predicates is that when you build a sentence with a predicate the result is true or false. This is because you have a sentence, so it’s either going to be true or false. When I say that Chelsea Clinton’s mother is Hilary, that is a true sentence. But if I say something like “the White House has the Lincoln Memorial as one of its physical parts,” that is a sentence of course, but it’s not true. It’s a false sentence. So predicates are sometimes called truth-functional relations because when you apply them to arguments, the resulting sentence will either be true or false.
Now a further point about the truth or falsity of a sentence made with a predicate is that whether a given sentence is true or false depends upon certain facts about the world and isn’t just a matter of logic all by itself. So for example, our example sentence states that Chelsea Clinton’s mother is Hillary Clinton. This happens to be true because, as a matter of fact, Hillary Clinton is Chelsea Clinton’s mother. So it’s true, and it’s true because of facts about the world.
The second sentence that we saw, which says that the Lincoln Memorial is a part of the White House, is false because it’s just a fact that the Lincoln Memorial is not a part of the White House.
Sometimes this feature of predicates is summed up by saying that they’re extra-logical relations. In other words, whether they result in true or false sentences depends on more than just pure logic, but is a matter of facts beyond the world of logic; facts about the physical world, for example.
Now let’s turn to some basic points about denotational functions. Some example denotational functions are #$MotherFn, #$BorderBetweenFn, and #$GroupFn. As opposed to predicates, which are mainly used to form sentences, functions are mainly used to form terms. And since these are complex (or compound) terms that are built out of other ones, they’re sometimes called non-atomic terms.
Let’s look at some examples using our example functions:
If we take the #$MotherFn function and apply it to one term, #$ChelseaClinton, we have a non-atomic term, which is the entire line of the first example below “Terms using these functions.”
Now, the #$BorderBetweenFn happens to take two arguments at a time. So when we apply it to two arguments, we have a term.
#$GroupFn takes one argument, so again, one term.
A very important feature of terms -- including those that are built with functions -- is that they denote things, that is they stand for or refer to things. So, the example of #$MotherFn applied to Chelsea Clinton denotes “Hillary Clinton.” You should think of that term as being equivalent to the compound English phrase or expression “the mother of Chelsea Clinton,” who is in fact Hillary Clinton.
You should think of the second example, where we applied the #$BorderBetweenFn to Sweden and Norway, as a non-atomic term that denotes the border between Sweden and Norway – in other words, a certain geographical line.
Non-atomic terms are like other terms in that you can apply a predicate or a function to a non-atomic term and therefore form a sentence or another (even more complex) non-atomic term.
Telling the difference between a predicate and a function in the CycL language is easy. Just remember that the name of a predicate always begins with a lower-case letter. With very few exceptions (that you don’t need to worry about at this point), only predicates start with lower-case letters. So if you see something starting with a lower-case letter, it’s a predicate. Functions, on the other hand, are a little looser as far as their possible names go. Usually, the name of a function will have Fn at the end of it, or sometimes somewhere in the middle. Almost always it will have an Fn as part of it. But that’s not a hard and fast rule. There are some exceptions, as you’ll learn, but for the most part, if you’ve got the Fn there, you know it’s a function.
To see some examples that are comparable to each other that we’ve already looked at, let’s review. You have #$mother, which is a predicate (you can tell because it’s lower-case), and that’s different from #$MotherFn, which is of course a function, not a predicate. The first one, as we know, can be applied to two arguments and it gives you a sentence. The second one applies to one argument and it gives you a non-atomic term.
Now, below that are two other examples that you haven’t seen yet. There’s a predicate called #$sponsors and there’s a corresponding function called #$SponsorFn-Agent. Now the predicate #$sponsors, like all predicates, can be used to form a sentence. The sentence there, “(#$sponsors #$GeneralMotors #$USOlympicTeam),” is a CycL sentence that’s equivalent to saying that General Motors is one of the sponsors of the US Olympic Team. Below that, where we have a non-atomic term built with a function, that applies the function SponsorFn-Agent to the USOlympicTeam. So, that is a non-atomic term. It’s not a sentence, it’s not something that’s true or false. It’s a term that denotes something. In this case, as you can probably figure out by the names of the terms in there, it is a non-atomic term that denotes…. Well, if you think about it, the US Olympic Team doesn’t have just one sponsor, it has a number of them. So what you might be able to surmise from that is that this term, this full non-atomic term, denotes, not just one particular sponsor (because there is no one sponsor of the US Olympic Team), it denotes the collection of sponsors of the US Olympic Team. And if you looked at the definition of #$SponsorFn, you would see clearly, because it would be stated, that that’s the case.
There are a couple of important features that every predicate and function has. First of all, arity. Arity has to do with how many arguments a predicate or function requires, or in other words, how many arguments you have to apply the function to at a given time to result in a meaningful sentence or term.
Then there’s also the notion of argument types, which has to do with what types of things a predicate or function requires as a particular argument.
We’ll be getting into arity and argument types in more detail in the next two lessons.
- Predicates are used to make sentences
- Predicates are truth-functional relations
- Predicates are extra-logical relations
- Functions are used to make non-atomic terms (NATs)
- NATs denote things
- Differentiating between predicates and functions in CycL
- Two central features of predicates and functions are arity and argument types
This concludes the lesson on the basics of predicates and denotational functions.