1 / 39

# tional Semantics - PowerPoint PPT Presentation

Computational Semantics http://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.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'tional Semantics' - Jeffrey

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation 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

• 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?

• Sentence: “John smokes”.

• Syntactic Analyses: S

NPVP

John smokes

• Semantics Construction: smoke(j)

• Inference:x.smoke(x)snore(x),smoke(j)

=> snore(j)

• Monday - Thursday: Semantics Construction

• Mon.+Tue.: Lambda-Calculus

• Wed.+Thu.: Underspecification

• Friday: Inference

• (Semantic) Tableaux

• 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.

• Meaning Representation in FOL

• Basic Semantics Construction

• -Calculus

• Semantics Construction with Prolog

• 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))

• 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.

• Meaning Representation in FOL 

• Basic Semantics Construction

• -Calculus

• Semantics Construction with Prolog

Basis: Context Free Grammar (CFG)

Grammar Rules:

S  NP VP

VP  TV NP

TV  love

NP  john Lexical Rules / Lexicon

NP  mary

...

The meaning of the sentence is constructed from:

• The meaning of the words: john, mary, love(?,?) (lexicon)

• Paralleling the syntactic construction (“semantic rules”)

• 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?

• 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?

• 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)?

• “Glueing” is known as Functional Application

• FA has the Form: [email protected]

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)

• Strip off the -prefix,

• Remove the argument (and the @),

• Replace all occurences of the -bound variable by the argument.

x.love(x,mary)@john

• love(x,mary)@john

• love(x,mary)

• love(john,mary)

S: John loves Mary

(yx.love(x,y)@mary)@john

NP: John

john

VP: loves Mary

yx.love(x,y)@mary

TV: loves

yx.love(x,y)

NP: Mary

mary

(yx.love(x,y)@mary)@john

=> (x.love(x,mary))@john

=> love(john,mary)

• -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)

• Meaning Representation in FOL 

• Basic Semantics Construction 

• -Calculus 

• Semantics Construction with Prolog

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

Binding

Strength

:- 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.“)

• 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 an argument to each DCG rule to collect semantic information.

• Phrase rules of our first semantic DCG:

s([email protected]) --> np(NP),vp(VP).

vp(IV) --> iv(IV).

vp([email protected]) --> tv(TV),np(NP).

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)}.

?- 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([email protected],Result):-betaConvert(Functor,lambda(X,Formula)),!,substitute(Arg,X,Formula,Substituted),betaConvert(Substituted,Result).

• 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):-

compose(Formula,Functor,Formulas),

betaConvertList(Formulas,Converted), compose(Result,Functor,Converted).

Formula = exists(x,man(x)&(lambda(z),walk(z)@x))

Functor = exists

Formulas = [x,man(x)&(lambda(z),walk(z)@x))]

Converted = [x,man(x)&walk(x)]

Result = exists(x,man(x)&walk(x))

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.)

go :-

resetVars,

s(Formula,Sentence,[]),

nl, print(Formula),

betaConvert(Formula,Converted),

nl, print(Converted).

NP: A man ~> x.man(x)

S: A man loves Mary

Let‘s try it in a system demo!

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.