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 Functor@Arg.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 = 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.