computational semantics http www coli uni sb de cl projects milca esslli l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Computational Semantics coli.uni-sb.de/cl/projects/milca/esslli PowerPoint Presentation
Download Presentation
Computational Semantics coli.uni-sb.de/cl/projects/milca/esslli

Loading in 2 Seconds...

play fullscreen
1 / 39

Computational Semantics coli.uni-sb.de/cl/projects/milca/esslli - PowerPoint PPT Presentation


  • 248 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 'Computational Semantics coli.uni-sb.de/cl/projects/milca/esslli' - Jeffrey


Download Now 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

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
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
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
Course Schedule
  • Monday - Thursday: Semantics Construction
    • Mon.+Tue.: Lambda-Calculus
    • Wed.+Thu.: Underspecification
  • Friday: Inference
    • (Semantic) Tableaux
the book
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
Today (Monday)
  • Meaning Representation in FOL
  • Basic Semantics Construction
  • -Calculus
  • Semantics Construction with Prolog
meaning representations
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
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 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
What we have done so far
  • Meaning Representation in FOL 
  • Basic Semantics Construction
  • -Calculus
  • Semantics Construction with Prolog
syntactic analyses
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
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
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
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
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
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
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
-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
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
Example: Beta-Reduction

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

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

=> love(john,mary)

in the background
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
What we have done so far
  • Meaning Representation in FOL 
  • Basic Semantics Construction 
  • -Calculus 
  • Semantics Construction with Prolog
slide27
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
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
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
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 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
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
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(Formula,Result) 1/2

betaConvert(Functor@Arg,Result):-betaConvert(Functor,lambda(X,Formula)),!,substitute(Arg,X,Formula,Substituted),betaConvert(Substituted,Result).

  • The input expression is of the form Functor@Arg.
  • 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) 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
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
Wrapping It Up

go :-

resetVars,

readLine(Sentence),

s(Formula,Sentence,[]),

nl, print(Formula),

betaConvert(Formula,Converted),

nl, print(Converted).

adding more complex nps
Adding More Complex NPs

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

S: A man loves Mary

Let‘s try it in a system demo!

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