Computational Semantics 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 VP VP TV NP TV love NP johnLexical Rules / Lexicon NP mary...

Example: Syntactic Analyses

Example: Semantic Lexicon

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 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: FA triggers a very simple operation: Replace the -bound variable by the argument. => love(john,mary)

-Reduction/Conversion 1.Strip off the -prefix, 2.Remove the argument (and 3.Replace all occurences of the -bound variable by the argument. 2.love(x,mary) 3.love(john,mary)

Semantics Construction with Lambdas S: John loves Mary ( y TV: loves y x.love(x,y) NP: Mary mary NP: John john VP: loves Mary y

Example: Beta-Reduction ( y => ( => love(john,mary)

In the Background -Calculus –A logical standard technique offering more than - abstraction, 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 :- 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 doesnt love her.) Binding Strength

Definite Clause Grammar Prologs 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: --> np(NP),vp(VP). vp(IV) --> iv(IV). --> 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, ?- …, betaConvert(Sem,Result). Result = smoke(mary) Note that we use some special predicates of freely available SWI Prolog (

betaConvert(Formula,Result) 1/2 betaConvert(Functor,lambda(X,Formula)), !, substitute(Arg,X,Formula,Substituted), betaConvert(Substituted,Result). 1.The input expression is of the form 2.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= Functor = exists Formulas = 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 Lets 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.