1.4.4 Advanced Topics: Proper Names and Transitive Verbs
As we've just learnt, the way we use 
s in our meaning representations reflects generalizations over the syntactic use of their natural language counterparts. Let's look at the representation of proper names and transitive verbs as further examples of this connection. We said before that the first-order counterparts of proper names are constant symbols, and that for example 
stands for ``John''. But while the semantic representation of a quantifying NP such as ``a woman'' can be used as a functor, surely such a constant symbol will have to be used as an argument. Will this be a problem for our semantic construction mechanism?
Proper names
In fact, there's no problem at all - if we only look at things the right way. We want to use proper names as functors, because syntactic structure suggests to treat them the same way as quantified noun phrases. But then we just shouldn't translate them as constant symbols directly. Let's keep their intended use in mind when we design the semantic representations for proper names. It's all a matter of abstracting cleverly. Indeed the -calculus offers a delightfully simple functorial representation for proper names, as the following examples show:
``Mary'': 
``John'': 
Role-Reversing
From outside (i.e. if we only look at the -prefix) these representations are exactly like the ones for quantified noun phrases. And - most importantly - they can be used in the same way: They are abstractions, thus they can be used as functors. However looking at the inside, note what such functors do. As always, they are essentially instructions to substitute their argument for the bound variable (i.e. 
or 
). But this time, this means that the argument becomes itself applied, namely to the constant symbol that stnds for the bearer of the name! Because the -calculus offers us the means to specify such role-reversing functors, proper names can be used as functors just like quantified NPs.
Transitive verbs
As an example of these new representations in action, let us build a representation for ``John loves Mary''. But before we can do so, we have to meet another challenge: ``loves'' is a transitive verb, it takes an object and forms a VP; we will want to apply it to its object-NP. And the resulting VP should be usable just like a standard intransitive verb; we want to be able to apply the subject NP to it. This is what we know in advance.
Given these requirements, a -expression like the simple 
(which we've seen in Section 1.4.1) surely won't do. After all, the object NP combining with a transitive verb is itself a functor. It would be inserted for 
in this -expression, but isn't applied to anything anywhere. So the result could never be 
-reduced to a well-formed first-order formula. How do we make our representation fit our needs this time? Let's try something like our role-reversing trick again; we'll assign ``loves'' the following -expression:
An example
Thus prepared we're now ready to have a look at the semantic construction for ``John loves Mary''. We can build the following tree:
How is this going to work? Let's look at the application at the S-node, and think through step by step what happens when we -convert it: Inside our complex application, the representation for the object NP is substituted for 
. It ends up being applied to something looking like an intransitive verb (
), namely an ``intransitive verb with a free variable''. This application is going to be no problem - it's structurally the same we would get if our object NP was the subject of a true intransitive verb. So everything is fine here.
Now the remaining prefix 
makes the complete VP-representation also function like that of an intransitive verb (from outside). And indeed the subject NP semantic representation finally takes the VP semantic representation as argument, again as if it was the representation of a true intransitive verb. So everything is fine here, too.
Trace the semantic construction!
Make sure you understand what is going on here by -reducing the expression at the S-node yourself!