computational semantics aljoscha burchardt, alexander koller, stephan walter, universität des...
TRANSCRIPT
Computational Semanticshttp://www.coli.uni-sb.de/cl/projects/milca/esslli
Aljoscha Burchardt,
Alexander Koller,
Stephan Walter,Universität des Saarlandes,
Saarbrücken, Germany
ESSLLI 2004, Nancy, France
Computational Semantics
• How can we compute the meaning of e.g. an English sentence?– What do we mean by “meaning“?– What format should the result have?
• What can we do with the result?
The Big Picture
• Sentence: “John smokes”.
• Syntactic Analyses: S
NPVP
Johnsmokes
• Semantics Construction: smoke(j)• Inference: x.smoke(x)snore(x),smoke(j)
=> snore(j)
Course Schedule
• Monday - Thursday: Semantics Construction– Mon.+Tue.: Lambda-Calculus– Wed.+Thu.: Underspecification
• Friday: Inference– (Semantic) Tableaux
The Book
• If you want to read more about computational semantics, see the forthcoming book:
Blackburn & Bos, Representation and Inference: A first course in
computational semantics. CSLI Press.
Today (Monday)
• Meaning Representation in FOL
• Basic Semantics Construction-Calculus
• Semantics Construction with Prolog
Meaning Representations
• Meaning representations of NL sentences
• First Order Logic (FOL) as formal language– “John smokes.“
=> smoke(j)
– “Sylvester loves Tweety.” => love(s,t)
– “Sylvester loves every bird.” => x.(bird(x) love(s,x))
In the Background: Model Theory
x.(bird(x) love(s,x)) is a string again!
• Mathematically precise model representation, e.g.: {cat(s), bird(t), love(s,t), granny(g), own(g,s), own(g,t)}
• Inspect formula w.r.t. to the model: Is it true?
• Inferences can extract information: Is anyone not owned by Granny?
FOL Syntax (very briefly)
FOL Formulae, e.g. x.(bird(x) love(s,x))
FOL Language– Vocabulary (constant symbols and
predicate/relation symbols)– Variables– Logical Connectives– Quantifiers– Brackets, dots.
What we have done so far
• Meaning Representation in FOL • Basic Semantics Construction-Calculus
• Semantics Construction with Prolog
Syntactic Analyses
Basis: Context Free Grammar (CFG)Grammar Rules:
S NP VPVP TV NPTV loveNP john Lexical Rules / LexiconNP mary...
Example: Syntactic Analyses
Example: Semantic Lexicon
Example: Semantics Construction
Example: Semantics Construction
Compositionality
The meaning of the sentence is constructed from:– The meaning of the
words: john, mary, love(?,?) (lexicon)
– Paralleling the syntactic construction (“semantic rules”)
Systematicity
• How do we know that e.g. the meaning of the VP “loves Mary” is constructed as love(?,mary) and not as
love(mary,?) ?
• Better: How can we specify in which way the bits and pieces combine?
Systematicity (ctd.)
• Parts of formulae (and terms), e.g. for the VP “love Mary”?– love(?,mary) bad: not FOL– love(x,mary) bad: no control over
free variable
• Familiar well-formed formulae (sentences): x.love(x,mary) “Everyone loves Mary.” x.love(mary,x) “Mary loves someone.”
Using Lambdas (Abstraction)
• Add a new operator to bind free variables:x.love(x,mary) “to love Mary”
• The new meta-logical symbol marks missing information in the object language (-)FOL
• We abstract over x.• How do we combine these new formulae
and terms?
Super Glue
• Glueing together formulae/terms with a special symbol @:
x.love(x,mary) john
x.love(x,mary)@john• Often written as x.love(x,mary)(john)• How do we get back to the familiar
love(john,mary)?
Functional Application
• “Glueing” is known as Functional Application
• FA has the Form: Functor@Argument
x.love(x,mary)@john• FA triggers a very simple operation:
Replace the -bound variable by the argument.
x.love(x,mary)@john
=> love(john,mary)
-Reduction/Conversion
1. Strip off the -prefix,
2. Remove the argument (and the @),
3. Replace all occurences of the -bound variable by the argument.
x.love(x,mary)@john1. love(x,mary)@john
2. love(x,mary)
3. love(john,mary)
Semantics Construction with Lambdas
S: John loves Mary(yx.love(x,y)@mary)@john
TV: lovesyx.love(x,y)
NP: Marymary
NP: Johnjohn
VP: loves Maryyx.love(x,y)@mary
Example: Beta-Reduction
(yx.love(x,y)@mary)@john
=> (x.love(x,mary))@john
=> love(john,mary)
In the Background
-Calculus – A logical standard technique offering more than -
abstraction, functional @pplication and β-reduction.
• Other Logics– Higher Order Logics
– Intensional Logics
• ...• For linguistics: Richard Montague (early seventies)
What we have done so far
• Meaning Representation in FOL • Basic Semantics Construction -Calculus • Semantics Construction with Prolog
Plan
Next, we
• Introduce a Prolog represenation.
• Specify a syntax fragment with DCG.
• Add semantic information to the DCG.
• (Implement β-reduction.)
Prolog Representation: Terms and Formulae
(man(john)&(~(love(mary,john))))
(happy(john)>(happy(mary)v(happy(fido)))
forall(x,happy(x))
exists(y,(man(y)&(~(happy(y))))
lambda(x,…)
Prolog Representation:Operator Definitions
:- op(950,yfx,@). % application
:- op(900,yfx,>). % implication
:- op(850,yfx,v). % disjunction
:- op(800,yfx,&). % conjunction
:- op(750, fy,~). % negation
forall(x,man(x)&~love(x,mary)>hate(mary,x))
(„Mary hates every man that doesn‘t love her.“)
BindingStrength
Definite Clause Grammar
• Prolog‘s built-in grammar formalism• Example grammar:
s --> np,vp.vp --> iv. vp --> tv,np....np --> [john].iv --> [smokes].
• Call: s([john,smokes],[]).
Adding Semantics to DCG
• Adding an argument to each DCG rule to collect semantic information.
• Phrase rules of our first semantic DCG:
s(VP@NP) --> np(NP),vp(VP).
vp(IV) --> iv(IV).
vp(TV@NP) --> tv(TV),np(NP).
Lexicon Of Our First Semantic DCG
np(john) --> [john].
np(mary) --> [mary].
iv(lambda(X,smoke(X))) -->
[smokes],{vars2atoms(X)}.
tv(lambda(X,lambda(Y,love(Y,X)))) -->
[loves],{vars2atoms(X),
vars2atoms(Y)}.
Running Our First Semantics Constrution
?- s(Sem,[mary,smokes],[]).
Sem = lambda(v1, smoke(v1))@mary
?- …, betaConvert(Sem,Result).
Result = smoke(mary)
Note that we use some special predicates of freely available SWI Prolog (http://www.swi-prolog.org/).
betaConvert(Formula,Result) 1/2
betaConvert(Functor@Arg,Result):-betaConvert(Functor,lambda(X,Formula)),!,substitute(Arg,X,Formula,Substituted),betaConvert(Substituted,Result).
1. The input expression is of the form [email protected]. The functor has (recursively) been reduced to
lambda(X,Formula).
Note that the code displayed in the reader is wrong. Corrected pages can be downloaded.
betaConvert(Formula,Result) 2/2
betaConvert(Formula,Result):-compose(Formula,Functor,Formulas),betaConvertList(Formulas,Converted),compose(Result,Functor,Converted).
Formula = exists(x,man(x)&(lambda(z),walk(z)@x))
Functor = existsFormulas = [x,man(x)&(lambda(z),walk(z)@x))]
Converted = [x,man(x)&walk(x)]Result = exists(x,man(x)&walk(x))
Helper Predicates
betaConvertList([],[]).
betaConvertList([F|R],[F_Res|R_Res]):- betaConvert(F,F_Res), betaConvertList(R,R_Res).
compose(Term,Symbol,Args):-
Term =.. [Symbol|Args].
substitute(…) (Too much for a slide.)
Wrapping It Up
go :-
resetVars,
readLine(Sentence),
s(Formula,Sentence,[]),
nl, print(Formula),
betaConvert(Formula,Converted),
nl, print(Converted).
Adding More Complex NPs
NP: A man ~> x.man(x)
S: A man loves Mary
Let‘s try it in a system demo!
Tomorrow
S: A man loves Mary
~> * love(x.man(x),mary)• How to fix this.• A DCG for a less trivial fragment of
English.• Real lexicon.• Nice system architecture.