Computational semantics http www coli uni sb de cl projects milca esslli
Download
1 / 39

tional Semantics - PowerPoint PPT Presentation


  • 244 Views
  • Uploaded on

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.

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

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 semantics http www coli uni sb de cl projects milca esslli l.jpg

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 l.jpg
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 l.jpg
The Big Picture

  • Sentence: “John smokes”.

  • Syntactic Analyses: S

    NPVP

    John smokes

  • Semantics Construction: smoke(j)

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

    => snore(j)


Course schedule l.jpg
Course Schedule

  • Monday - Thursday: Semantics Construction

    • Mon.+Tue.: Lambda-Calculus

    • Wed.+Thu.: Underspecification

  • Friday: Inference

    • (Semantic) Tableaux


The book l.jpg
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 l.jpg
Today (Monday)

  • Meaning Representation in FOL

  • Basic Semantics Construction

  • -Calculus

  • Semantics Construction with Prolog


Meaning representations l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
What we have done so far

  • Meaning Representation in FOL 

  • Basic Semantics Construction

  • -Calculus

  • Semantics Construction with Prolog


Syntactic analyses l.jpg
Syntactic Analyses

Basis: Context Free Grammar (CFG)

Grammar Rules:

S  NP VP

VP  TV NP

TV  love

NP  john Lexical Rules / Lexicon

NP  mary

...






Compositionality l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
Functional Application

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


Reduction conversion l.jpg
-Reduction/Conversion

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


Semantics construction with lambdas l.jpg
Semantics Construction with Lambdas

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


Example beta reduction l.jpg
Example: Beta-Reduction

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

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

=> love(john,mary)


In the background l.jpg
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 far26 l.jpg
What we have done so far

  • Meaning Representation in FOL 

  • Basic Semantics Construction 

  • -Calculus 

  • Semantics Construction with Prolog


Slide27 l.jpg
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 l.jpg
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 l.jpg
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.“)


Definite clause grammar l.jpg
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 l.jpg
Adding Semantics to DCG

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


Lexicon of our first semantic dcg l.jpg
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 l.jpg
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 l.jpg
betaConvert(Formula,Result) 1/2

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 2 2 l.jpg
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 = exists

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

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

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


Helper predicates l.jpg
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 l.jpg
Wrapping It Up

go :-

resetVars,

readLine(Sentence),

s(Formula,Sentence,[]),

nl, print(Formula),

betaConvert(Formula,Converted),

nl, print(Converted).


Adding more complex nps l.jpg
Adding More Complex NPs

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

S: A man loves Mary

Let‘s try it in a system demo!


Tomorrow l.jpg
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.


ad