Download - Semantic Construction
![Page 1: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/1.jpg)
Semantic Construction
lecture 2
![Page 2: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/2.jpg)
Semantic Construction
• Is there a systematic way of constructing semantic representation from a sentence of English?
• This question is too ambitious for now. • Let's begin with a more specific one.• Is there a systematic way of translating simple
sentences such as:Vincent likes MiaEvery woman snortsEvery boxer loves a woman
• into 1st-order logic?
![Page 3: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/3.jpg)
Meaning flows from the lexicon
• Assume the natural language sentence Vincent likes Mia should be represented by the 1st-order sentence like(vincent,mia).
• The proper name Vincent is what gives rise to the constant vincent, and Mia is what gives rise to the constant mia, and the verb likes contributes the 2-place relation symbol like.
• A simple observation, but it leads to an important generalization: meaning ultimately flows from the lexicon.
![Page 4: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/4.jpg)
What about function words?
• Every woman snorts is represented asAx(woman(x) → snort(x)).
• What exactly does the word Every contribute to this representation?
• How can we be precise about what its contribution is?
![Page 5: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/5.jpg)
Syntax also plays a role
• Why did we get like(vincent,mia) as the representation and not (say) like(mia,vincent)– Subject is Vincent– Object is Mia
• Notions like Subject and Object come from the syntactic structure of the sentence.
• The basic principle here is that the syntactic structure of the natural language sentence should guide the process of semantic construction.
![Page 6: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/6.jpg)
The three tasks
This gives us a guide to how to proceed. We need to...
• Task 1 Specify a reasonable syntax for the fragment of natural language of interest.
• Task 2 Specify semantic representations for the lexical items.
• Task 3 Specify the translation compositionally. That is, we should specify the translation of all expressions in terms of the translation of their parts.
![Page 7: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/7.jpg)
Task 1:Specify syntax for NL fragment.
• Categorial Grammar• Context Free Grammars• Interaction Grammars• Head Driven Phrase Structure Grammar (HPSG)• Lexical Functional Grammar (LFG)• Tree Adjoining Grammars (TAG)• Minimalism, GB, TG, or some other Chomskyan
framework.• Nice computational choice for a first exploration:
Definite Clause Grammars (DCGs)
![Page 8: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/8.jpg)
Definite Clause Grammar
%grammar
s --> np, vp.
np --> pn.
np --> det, noun.
vp --> iv.
vp --> tv, np.
%lexicon
noun --> [woman]
noun --> [foot,massage].
iv --> [walks].
tv --> [loves].
tv --> [likes].
pn --> [mia].
pn --> [vincent].
det --> [a].
det --> [every].
![Page 9: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/9.jpg)
Definite Clause Grammars
• They are a natural notation for specifying grammars which automatically have a computational interpretation.
• For example, by posing the query?- s([mia,likes,a,foot,massage],[ ]) we can test whether this sentence belongs to the fragment the grammar describes.
• For more on DCGs, look at Learn Prolog Now! which is available at http://www.learnprolognow.org.
• Tasks 2 and 3
![Page 10: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/10.jpg)
The Lambda Calculus
• The lambda operator marks missing information by binding variables.
• Here is a simple lambda expression λx.man(x) • The prefix λx binds the occurrence of x in
man(x);• λx.man(x) can be read as: ‘I am the 1-place
predicate man, and I am looking for a term to fill my argument slot.
![Page 11: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/11.jpg)
Functional Application
• Functional application The @ operator is used to indicate “functional application”.
• That is, it indicates that we wish to perform a substitution. Example:
λx.man(x)@vincent• The expression λx.man(x) is called the functor.• The expression vincent is called the argument.• Bracketing: ( ( λx.man(x) ) @ ( vincent ) )• Schematically: (functor @ argument)
![Page 12: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/12.jpg)
β -conversion
• The required substitution is performed by β -conversion (which is sometimes called β -reduction):
• From λx.man(x)@vincent• β -conversion produces man(vincent)• Basically, we throw away the λx. at the
start of the expression, and substitute the argument for all occurrences of x that were bound by λx.
![Page 13: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/13.jpg)
When can we β-convert?
• For β-conversion to be applicable, the functor must have the form λx.expression
• Such expressions are usually called lambda abstractions, or abstractions.
• That is, given an expression of the form λx.expression @ argument we can β -convert, because the functor expression is a lambda abstraction.
• One the other hand, given an expression of the form functor @ argument where functor is not of the form λx.expression, then we cannot β-convert.
![Page 14: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/14.jpg)
More Complex Example
• Our semantic representation of a woman will be: λQ. ∃x(woman(x) ∧ Q@x)
• We use the variable Q to indicate that:– some information is missing– where this information has to be plugged in– We can use lambda notation to build up
patterns of meaning or patterns of representation, explicitly indicating where the various bit and pieces have to be glued into place.
![Page 15: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/15.jpg)
Every boxer growls
• Step 1: assign lambda expressions to lexical items
• boxer: λy.boxer(y) growls: λx.growl(x)every: λP.λQ. ∀x(P@x→Q@x)
![Page 16: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/16.jpg)
Every Boxer Growls
• Step 2: associate the NP node with the application that has the DET representation as functor and the NOUN representation as argument.
![Page 17: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/17.jpg)
every boxer (NP)λP.[λQ. ∀x((P@x)→(Q@x))]@ λy.boxer(y)
every (DET)
λP.λQ.∀x((P@x)→(Q@x))
boxer (NOUN)
λy.boxer(y)
![Page 18: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/18.jpg)
Beta Conversion
• The node for Every boxer is an application, and the left hand expression is an abstraction, so we can β-convert.
• every boxer:λP.[λQ. ∀x((P@x)→(Q@x))]@ λy.boxer(y)
• every boxer: λQ. ∀x((λy.boxer(y)@x)→(Q@x)) • But the resulting expression contains a
subexpression λy.boxer(y)@x. So we can β -convert again.
• every boxer: λQ. ∀x((λy.boxer(y)@x)→(Q@x)) every boxer: λQ. ∀x(boxer(x)→(Q@x)
![Page 19: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/19.jpg)
• every boxer: λQ. ∀x(boxer(x)→(Q@x)
• growls λy. growl(y)
• every boxer(growls)
• beta-reduction:
![Page 20: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/20.jpg)
Proper Nouns
• Quantifying noun phrases can clearly be used as functors.
• But what about NPs like Vincent? If the semantic representation of Vincent is just the constant vincent, then we cannot do this.
• Here is a bad answer: say that in such cases we apply the verb semantics to the noun phrase semantics.
• Note that this seems to work: applying λx.growl(x) to vincent yields growl(vincent), which seems right. So why is it bad?
![Page 21: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/21.jpg)
Handling Proper Names
• Fortunately, there is a very easy way to give a representation to Vincenta nd other names which allows us to use the representation as a functor, and, at the same time, puts the constant vincent in the right place.
• Vincent: λP.(P@vincent)• Mia: λP.(P@mia)• These representations can be used as functors.
In effect they say: apply my argument to the constant I contain!
![Page 22: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/22.jpg)
Vincent growls
• We can build up the semantic representation for Vincent growls simple by applying the NP semantics to the VP semantics.
• NP semantics: λP.(P@vincent) VP semantics: λw.growls(w)
• λP.(P@vincent) @ λw.growls(w)(λw.growls(w)@vincent)growls(vincent )
• Thus the method works. • In effect we are seeing that NPs are generalised
quantifiers.
![Page 23: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/23.jpg)
Is beta-conversion safe
The representations
• λx.λy.bloogle(x,y)
• λz.λw.bloogle(z,w)
are intended to have the same effect.
• There are situations, however, when they do not
![Page 24: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/24.jpg)
Is beta conversion safe
• Things can go wrong if we apply a lambda expression to a variable that occurs bound in the functor.
• For example, if we apply λx.λy.bloogle(x,y) to the variable w we obtain λy.bloogle(w,y) which is what we want.
• On the other hand, if we apply λz.λw.bloogle(z,w) to w we obtain λw.bloogle(w,w).
• This is not what we want. The variable w has become accidentally bound.
![Page 25: Semantic Construction](https://reader036.vdocuments.net/reader036/viewer/2022062723/56813cca550346895da674f4/html5/thumbnails/25.jpg)
α-conversion
• α-conversion is the process of replacing (renaming) bound variables. e.g. we obtain λx.λy.bloogle(x,y) from λz.λw.bloogle(z,w) by α-conversion
• To prevent accidental binding, we always α-convert before carrying out β -conversion.
• In particular, we always rename all the bound variables in the functor so they are distinct from all the variables in the argument.
• So our fundamental combination method is really α-conversion (for safety) followed by β -conversion.