On Denoting (1905) | Hacker News Reader

On Denoting (1905)

users.drew.edu

34 pointscallumlocke12 comments

I wrote my master's thesis on this in 1985. Back then there was a branch of the AI research community that was hung up on the following problem: John knows Mary's phone number. Mary and Bill have the same phone number, but John doesn't know this. If we translate this into formal logic in the straightforward manner it seems we can draw the false conclusion that John knows Bill's phone number:

Knows(John, Phone(Mary))

Phone(Mary) = Phone(Bill)

Therefore: Knows(John, Phone(Bill)) by substitution of equals

How do we prevent this? The answer, of course, is to distinguish between Phone(Mary) and "Phone(Mary)". When we say that John knows Mary's phone number what we really mean is that John knows that "Mary's phone number" denotes X for some particular X, i.e.

Exists(x): Knows(John, denotes("Phone(Mary)", x))

Because "Phone(Mary)" != "Phone(Bill)" (despite the fact that Phone(Mary) = Phone(Bill)) you can no longer draw the false conclusion.

I once had the opportunity to chat with John McCarthy and I presented this solution to him and he said (I'm paraphrasing), "Yes, that's what makes QUOTE in Lisp such a cool idea."

While you implicitly state this, the AI system is not wrong when it states that: Know(John,Phone(Bill)). The only problem stems from our human projection of what Know means. We assume that Know means to know it belongs to someone, while the system merely claim that John knows a number and that number belongs to Bill.

As you state, that meaning really maps to something like KnowBelongTo(John,Phone(Bill)), which doesn't become true when Phone(Mary) = Phone(Bill), as its definition would not be tied to Phone(X) but to BelongTo(X).

> The only problem stems from our human projection of what Know means.

It's a little trickier than that. If you allow substitution of equals (the technical term for this is that your logic is "extensional" rather than "intensional") then you get this:

Phone(Mary) = Phone(Bill) = 555-1212

Knows(John, Phone(Mary)) ==> Knows(John, 555-1212)

> KnowBelongTo(John,Phone(Bill))

You mean:

KnowsPhoneNumberBelongsTo(John, 555-1212, Mary)

And yes, that works, but it gets rather unwieldly. You can try to fix this using second-order logic:

KnowsRelation(John, phone-of, Mary, 555-1212)

or third-order:

Knows(John, relation, phone-of, Mary, 555-1212)

but then your inference rules start to get rather hairy.

Why not simply model Phone as a relation:

    Knows(John, Phone(Mary, X))

(and so Knows ⊆ Person × (Person × Number))? After all, Knows(John, Phone(Mary)) doesn't really model the problem at all, as Phone(Mary) is just some integer, and that formalization simply denotes a relation between John and some integer, while "John knows Mary's phone number" really means that John knows that Mary and the number X are related by the Phone relation.

> Phone(Mary) is just some integer

Exactly right. But the problem is that if Phone(Mary) is a function that returns an integer, then what is Phone(Mary, X)? If you're going to be syntactically consistent it must be a function of two arguments that returns a value. It's probably a predicate that returns true or false. So Phone(Mary, X) == True IFF X is Mary's phone number. But now you have the same problem of distinguishing Phone(Mary, X) and "Phone(Mary, X)" as you did Phone(Mary) and "Phone(Mary)".

It's even worse now because extensionally (i.e. where functions applied to arguments are equivalent to their values) you can now substitute any true statement for Phone(Mary, X) and obtain another true statement under the law of substitution of equals.

It seems that the missing piece here is that John does not know that Phone(Mary) = Phone(Bill), and thus he (or we) cannot draw the conclusion Knows(John, Phone(Bill)). In order words, inference of items under Knows(.) must use only items under Knows(.) .

> In order words, inference of items under Knows(.) must use only items under Knows(.)

Yes, but it's trickier than that. For example, you want the knowledge scoped not only by the predicate Knows, but also by who knows it. From Knows(A, P->Q) and Knows(B, P) you do not want to be able to deduce Knows(A, Q) or Knows (B, Q) unless A=B.

There are other issues. For example, suppose John and Mary have never met but John passes Mary on the street and hears her say, "My phone number is 555-1212." Now if you asked John, "Do you know Mary's phone number?" he would say no. But if you pointed to Mary and asked, "Do you know that person's phone number?" he would say yes. That is why it is useful to distinguish between Mary and "Mary". Exists(X): Knows(John, phone-of(Mary, X)) is true, but Knows(John, Name-of(Mary, "Mary")) is not.

Heavily influential to all of this was Frege's 'on Sense and Reference'. Best link I can give from my mobile is to a search, where you can find pdfs and the helpful wiki entry: https://www.google.com/search?q=on+sense+and+reference

I like that this essay is basically just describing what a noun is, but the word "noun" doesn't appear in it.

It really isn't basically just describing what a noun is.

It's about the surprisingly subtle logical structure underlying how we use noun phrases; about qualifiers like "a", "some" and "the"; about a perhaps-surprising feature of language, namely that to the best way to explain what some term means may involve explaining how to rewrite whole sentences including that term in a different form.

it's really about variables, names and references, not nouns.

It's really distinguishing the logical structure of a sentence from the grammatical structure.

The explanation for why "The present king of France is bald" is the example Russel gives, where it might be hard to say this statement is false when there is no current king of France.

Another interesting example is "The average woman has 2.2 children." If you intuitively think that noun phrases refer to things (rather than sets), you'd have to admit the existence of some sort of an "average woman" and the property of having 2.2 kids.

Reply on news.ycombinator.com