; Packed Derivation of Meaning Representations
Documents
User Generated
Resources
Learning Center
Your Federal Quarterly Tax Payments are due April 15th

Packed Derivation of Meaning Representations

VIEWS: 5 PAGES: 58

• pg 1
```									    Packed Computation of
Exact Meaning Representations

Iddo Lev
Department of Computer Science
Stanford University
Outline
    Motivation
    From Syntax to Semantics
    Packed Computation
    Conclusion

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   2
Natural Language Understanding

• How can we improve accuracy?
• Let’s take it for a moment to the extreme
– Exact NLU applications

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   3
Example: Logic Puzzles
Six sculptures—C, D, E, F, G, and H—are to be exhibited in
rooms 1, 2, and 3 of an art gallery.
Sculptures C and E may not be exhibited in the same room.
Sculptures D and G must be exhibited in the same room.
If sculptures E and F are exhibited in the same room, no
other sculpture may be exhibited in that room.
At least one sculpture must be exhibited in each room, and
no more than three sculptures may be exhibited in any room.

1. If sculpture D is exhibited in room 3 and sculptures E and F
are exhibited in room 1, which of the following may be true?
(A) Sculpture C is exhibited in room 1.
(B) No more than 2 sculptures are exhibited in room 3.
(C) Sculptures F and H are exhibited in the same room.
(D) Three sculptures are exhibited in room 2.
(E) Sculpture G is exhibited in room 2.
April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   4
Example: Logic Puzzles

If sculptures E and F are exhibited in the same room, no
other sculpture may be exhibited in that room.

exact meaning representation:

x.[(room(x)  exhibited-in(E,x)  exhibited-in(F,x)) 
¬y.sculpture(y)  y  E  y  F  exhibited-in(y,x)]

April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   5
Example:
• MSCS Degree Requirements
– A candidate is required to complete a program of 45
units. At least 36 of these must be graded units, passed
with an average 3.0 (B) grade point average (GPA) or
higher. The 45 units may include no more than 21 units of
courses from those listed below in Requirements 1 and 2.
…
– Has Patrick Davis completed the program?
– Can/must Patrick Davis take CS287?

• Similar to logic puzzles:
– General constraints + specific situation

April 17, 2007     Iddo Lev, Packed Computation of Exact Meaning Representations   6
Exact NLU
• More examples
– Word problems
• Logic puzzles
• Math, physics, chemistry questions
– Simple regulation texts, controlled language
– NL interfaces to databases
• Like SQL, but looks like NL
– “Almost correct” (“only slightly wrong”) is not good enough
– Simple approximations won’t do
• E.g. syntactic matching between text and questions
• Because answer does not appear explicitly in the text
– Need exact calculation of NL meaning representations
• Answer needs to be inferred from the text
• Need to carefully combine information/meaning throughout the text

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations   7
Structural Semantics
• Need to rely on high-quality meaning representations and
linguistic knowledge
– In particular, structural semantics
• Meaning of functional words
• Logical structure of sentences
• Essential for exact NLU tasks
• Could also improve precision of other NLP tasks
• T: Michael Melvill guided a tiny rocket-ship more than 100 kilometers
above the Earth.
• H: A rocket-ship was guided more than 80 kilometers above the
Earth. Follows
• H: A rocket-ship was guided more than 120 kilometers above the
Earth. Does not follow
• Relatively small size of knowledge
• Functional:    #functional words  400 #grammar rules  400
• Lexical:       #verb frames  45,000             #nouns > 100,000

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations   8
My Dissertation
• How to map syntactic analysis to meaning representations
• How to compute all meaning representations efficiently
Focus of this talk

• Linguistic analysis of advanced NL constructions using the
above framework
–     anaphora     (interaction with truth conditions)
–     comparatives
–     reciprocals    (each other, one another)
–     same/different
• How to translate meaning representations to
inference representations (FOL)

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations           9
Structural Semantics Challenges

• When analyzing one sentence:
– (1) Bills 2 and 6 are paid on the same day as each other.
• it might seem enough to use:
– x.day(x)paid-on(bill2,x)paid-on(bill6,x)
• But this is not enough when we consider other sentences:
– (2) John, Mary, and Frank like each other.
– each_other({john,mary,frank}, xy.like(x,y))
• Goal
– Uniformity: one analysis of “each other” for both (1) and (2).
• Should interact correctly with “the same” in (1).
– Solution should also be consistent with “different”, “similar”:
• Men and women have a different sense of humor (than each other).

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations   10
Outline
 Motivation

 From Syntax to Semantics
 Packed Computation
 Conclusion

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   11
From Syntax to Semantics
• How do we get from one parse tree to a semantic
representation?
– Classic Method (Montague): one-to-one correspondence:
assign a lambda-term to each syntactic node

S     x. [dog(x)  bark(x)]

λR. x. [dog(x)  R(x)]      NP

VP
|
Det                  Noun                       V
every                   dog                    barks
λP.λR. x. [P(x)  R(x)]      λy.dog(y)              λz. bark(z)

April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   12
Problem 1: Floating Operators
S

NP                VP

V      NP           PP

NP

Frank introduced Rachel to Patrick.

introduce-to(frank, rachel, patrick)

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   13
Problem 1: Floating Operators
S

NP                VP

V      NP           PP
NP
N’
RC
Det                              VP
N                  VP         NP
Frank introduced Rachel to every person who visited me that summer.

every(λx.person(x)visit(x,me),
λx.introduce-to(frank, rachel, x))

every(P,Q) x. [P(x)  Q(x)]

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations        14
Problem 1: Floating Operators

S                                                       S
NP           VP                                       NP              VP
N’                                                     N’
A brave sailor walked by.                     An occasional sailor walked by.

a(λx.[sailor(x)brave(x)],                    occasionally(a(λx.sailor(x),
λx.walk-by(x))                                             λx.walk-by(x)))

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations     15
Problem 2: More Than One Meaning

“In this country, a woman gives birth every 15 minutes.
Our job is to find that woman, and stop her.”
-- Groucho Marx

every 15 minutes                 a woman
a woman                         every 15 minutes
gives birth                      gives birth

You may not smoke.                    All these books are not interesting.
You may not succeed.                  All that glitters is not gold.

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations            16
Glue Semantics

• Glue Semantics:
A flexible framework for mapping syntax to semantics
– Pieces of syntax correspond to pieces of semantics
– Pieces of semantics combine with each other according to
constraints
• Like jigsaw puzzle, but possibly with more than one solution
– Not a simple one-to-one mapping

• References
– Dalrymple et al. Semantics and Syntax in Lexical Functional Grammar. 1999
Mary Dalrymple. Lexical Functional Grammar. 2001
Asudeh, Crouch, Dalrymple. The syntax-semantics interface. 2002

April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   17
Glue Semantics
(simplified example)
S
NP                 VP
NP
Name         V          Name               statements
John         saw        Mary
mary
xy.see(x,y)
john

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations              18
Glue Semantics
(simplified example)
Sa
b NP               VP
NP c
Name          V         Name                 statements
John        saw        Mary
mary : c
xy.see(x,y) : b  c  a
john : b

derivation                                        prover

john : b         xy.saw(x,y) : b  c  a
mary : c         y.saw(john,y) : c  a
saw(john,mary) : a
gain: order of combination does not have to follow tree hierarchy
April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations              19
Problem 1: Floating Operators
S                                                            S
NP                 VP                                         NP                VP

λx.[sailor(x)brave(x)]                              λQλR.occasionally[Q(λx.sailor(x),R)]
N’                                                           N’

A         brave        sailor      walked by.               An           occas.         sailor     walked by.
λPλR.a(P,R)               λx.sailor(x) λx.walk-by(x)        λPλR.a(P,R)                   λx.sailor(x) λx.walk-by(x)

λPλx.[P(x)brave(x)]                                        λPλQλR.occasionally[Q(P,R)]

a(λx.[sailor(x)brave(x)],                        occasionally[a(λx.sailor(x),
λx.walk-by(x))                                                 λx.walk-by(x))]

April 17, 2007            Iddo Lev, Packed Computation of Exact Meaning Representations                   20
Glue Semantics
S a                                       Flexible handling of
b NP               VP                                  floating operators.

N’ c
λPλR.a(P,R) : c  (b  a)  a
An             occas.      sailor     walked by.            λx.sailor(x) : c

λx.walk-by(x) : b  a

c       c  (b  a)  a                          λS.occasionally[S] : a  a
ba              (b  a)  a
a                               aa
a

occasionally[a(λx.sailor(x),
λx.walk-by(x))]

April 17, 2007           Iddo Lev, Packed Computation of Exact Meaning Representations            21
Glue Semantics
(simplified example)
Can yield more than one meaning.

A woman gives birth every 15 minutes.

“gives birth”              G:a
“a woman”                  A: a  a
“every 15 minutes”         E:aa

two possible derivations:

G:a         A: a a                            G:a           E:aa
A(G) : a          E:aa                         E(S) : a        A:aa
E(A(G)) : a                                    A(E(S)) : a

April 17, 2007    Iddo Lev, Packed Computation of Exact Meaning Representations              22
Glue Semantics

• Shared labels constrain how statements combine
– “Resource Sensitive”:
Use each statement exactly once
– Inference rules:
Application                        Abstraction

[x:A]
:A      :AB                           ¦
():B                           :B
Linear Logic
x.:AB
(implicative fragment)

• In Glue Semantics, can impose further constraints
on combinations.
April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations              23
Outline
 Motivation

 From Syntax to Semantics

 Packed Computation
 Conclusion

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   24
Ambiguity
• Flying planes can be dangerous. Therefore, only
licensed pilots are allowed to do it.
• Flying planes can be dangerous. Therefore, some
people are afraid to ride in them.

• We cannot always disambiguate the sentence
just by looking at the sentence itself.
• We sometimes need to take the larger context
and information into account.

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   25
Ambiguity
Alternatives multiply across layers…
Morphology

Reasoning
Semantics
Syntax

KR
Text

… so we can’t keep all the alternatives separately

April 17, 2007                Iddo Lev, Packed Computation of Exact Meaning Representations               26
Early Pruning
• Select most likely analysis at each level
• Oops: Strong constraints may reject the so-far-best
(and only) option

Statistics

X              X X
Morphology

Reasoning
Semantics
Syntax

X

KR
Text

Locally less likely option
but globally correct
April 17, 2007            Iddo Lev, Packed Computation of Exact Meaning Representations               27
Packing
The sheep liked the fish.                         More than one sheep?
More than one fish?
Options multiplied out
The sheep-sg liked the fish-sg.
The sheep-pl liked the fish-sg.
The sheep-sg liked the fish-pl.
The sheep-pl liked the fish-pl.

Options packed
sg                sg
The sheep          liked the fish
pl                pl

Packed representation:
– Encodes all analyses without loss of information
– Common items represented and computed just once

April 17, 2007     Iddo Lev, Packed Computation of Exact Meaning Representations             28
Packing
•      Calculate compactly all analyses at each stage
•      Push ambiguities through the stages
•      Possibly, filter and keep only N-best at each stage
in a packed form (not only 1-best)
•      This approach is being pursued in the XLE system
at PARC (and Powerset Inc.)
–        (Maxwell & Kaplan ’89,93,95)

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations   29
Packing In Syntax: Chart Parser

A chart parser for a context-free grammar can compute an
exponential number of parse trees in O(n3) time by
representing and computing them compactly.

we have:

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   30
Packed Structures
XLE manages natural language ambiguity by packing similar
structures and managing them under a free-choice space

C-structure forest                                          Packed F-structure

Choice Space:         true  A1  A2
A1  A2  false
April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations         31
Currently in XLE
Text                                     semantic rewrite rules

FST

morph.                                  glue             glue
spec.           prover
parser
unpack F-str1              Glue1            MR1    pack
C-str            F-str
:                :                    MR    KR
:                :
C-F                 F-strn           Gluen            MRn

= packed

= packed calculation + possibly filter N-best

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations           32
The Goal
Text

FST

morph.

parser
Glue
C-str            F-str                                                        MR    KR
statements
glue                               glue
C-F                                                 prover
spec.

= packed

= packed calculation + possibly filter N-best

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations          33
Goal: Packed Meaning Representation

Bill saw the girl with the telescope.
a:1 e. see(e)  agent(e,bill)                   a:2 e. see(e)  agent(e,bill) 
theme(e,the(x.girl(x))                         theme(e, the(x. girl(x) 
with(e,the(y.tele(y)))                                         with(x,the(y.tele(y))) )

e. see(e)  agent(e,bill)  ●

●●

theme(e, the(x. ● ))

●●

girl(x)                     with(●,the(y.tele(y)))
x e

packed meaning representation
April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations                           34
Glue Specification
Glue specification – connecting syntactic and semantic pieces
NTYPE(f, NAME), PRED(f,     p)  p : f

NTYPE(f, COMMON), PRED(f,     p)  λx.p(x) : fv  fr

F-Structure

glue statements

john : a

λx.cake(x) : bv  br

“John ate the cake.”
April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations             35
Packed Glue Input
Packed F-structure

NTYPE(f, NAME), PRED(f,   p)  p : f e

Glue specification

{1} e.see(e) : aveart
{2} P.e.P(e) : (aveart)at
{3} bill : be
“Bill saw the girl with the telescope.”
{4} xPe.P(e)agent(e,x) : be(aveart)(aveart)
{5} P.the(P) : (gvegrt)ge
{6} x.girl(x) : gvegrt
This combines                                       {7} xPe.P(e)theme(e,x) : ge(aveart)(aveart)
Glue Semantics                                      {8} P.the(P) : (hvehrt)he
+ packing                                           {9} x.tele(x) : hvehrt


{10} A1: yPe.P(e)with(e,y) : he(aveart)(aveart)
at the input level                                  {11} A2: yPx.P(x)with(x,y) : he(gvegrt)(gvegrt)

April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                   36
Non-packed Prover (Hepple’96)
Rule:

Input:                                             : A | S1           : AB | S2
f : c c d      q:c        r:c                           () : B | S1  S2
provided S1  S2 = 
Chart:
meaning   category       span
f     c c d        {1}
q     c              {2}                     cannot combine:
r     c              {3}                     {2}{1,2}  
f(q)    cd            {1,2}
f(r)    cd            {1,3}
complete derivation
f(q,r)   d              {1,2,3}
Output:                                                         (all indices were used)
f(r,q)   d              {1,2,3}

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations          37
Syntactic Ambiguity
“Time flies like an arrow. Fruit-flies like a banana.”

-- Groucho Marx

April 17, 2007    Iddo Lev, Packed Computation of Exact Meaning Representations            38
Naive Packed Algorithm
•
– A1: [[John]a thinks that [[time]d flies [like [an arrow]c]]b]g
– A2: [[John]a thinks that [[time flies]f like [an arrow]c]b]g

• The chart algorithm will discover one history for
[[time]d flies [like [an arrow]c]]b under A1
• It may then continue under A1 with “John thinks that”
• It will later discover a history for
[[time flies]f like [an arrow]c]b under A2
• So it will have to redo the work for “John thinks that”
under A2

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   39
Non-Packed Prover
– Forget about meaning terms for now
• (can reconstruct them after the derivation finishes)
– Combine histories according to topological order of category graph

{1}      {2} {3}            {4}
ab            a            ac     category
graph
mean.    category    span               {5}
q       ab         {1}               bcd              b {1,2}      c {2,4}
{1,3}        {3,4}
p       a           {2}
{1,2,5}
r      a           {3}                            cd
{1,3,5}
s      ac         {4}
t      bcd       {5}
u       df         {6}                   t(q(p),s(r))     d          t(q(r),s(p))
df             {1,2,3,4,5}
{6}
f {1,2,3,4,5,6}

April 17, 2007        Iddo Lev, Packed Computation of Exact Meaning Representations                40
Packed Derivation
•   (Simplified example)
– A1: [[John]a thinks that [[time]d flies [like [an arrow]c]]b]g
– A2: [[John]a thinks that [[time flies]f like [an arrow]c]b]g

premises       choice
john         a          {1} 1
think        abg      {2}
anarrow      c          {3}
time         d          {4} A1
fly          deb      {5}
like         ce        {6}
timeflies    f          {7} A2
like         fcb      {8}

April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations   41
Packed Derivation
•   (Simplified example)
– A1: [[John]a thinks that [[time]d flies [like [an arrow]c]]b]g
– A2: [[John]a thinks that [[time flies]f like [an arrow]c]b]g

premises          choice
john         a          {jn}   1
think        abg      {th}
anarrow      c          {ar}
time         d          {t}    A1
fly          deb      {f}
like         ce        {k1}
timeflies    f          {tf}   A2
like         fcb      {k2}

April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations   42
Packed Derivation
 Imagine how each derivation works separately;
then figure out how to pack.

premises          choice
john         a          {jn}   1
{f}     {t}       {k1}        {ar}
think        abg      {th}
anarrow      c          {ar}
time         d          {t}   A1                          {k1,ar}                        {jn}   {th}
fly          deb      {f}                {t,f}
like         ce        {k1}                         {t,f,k1,ar}
{jn,th}
timeflies    f          {tf} A2
like         fcb      {lk2}
{jn,th,t,f,k1,ar}

Category graph
April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                           43
Packed Derivation
 Imagine how each derivation works separately;
then figure out how to pack.

{tf}           {k2}
premises          choice
john         a          {jn}   1
{ar}
think        abg      {th}                                                                       {tf,k2}

anarrow      c          {ar}                                                         {tf,k2,ar}
time         d          {t}   A1                                                    {jn}           {th}
fly          deb      {f}
like         ce        {lk1}
{jn,th}
timeflies    f          {tf} A2
like         fcb      {k2}
{jn,th,tf,k2,ar}

Category graph
April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                              44
Packed Derivation
 Imagine how each derivation works separately;
then figure out how to pack.

{tf}           {k2}
premises          choice
john         a          {j}    1
{f}      {t}       {k1}        {ar}
think        abg      {th}                                                                                     {tf,k2}

anarrow      c          {a}
time         d          {t}    A1                             {k1,ar}                             {jn}           {th}
fly          deb      {f}                 {t,f}                                     A2:{tf,k2,ar}
like         ce        {k1}                        A1:{t, f,k1,ar}
{jn,th}
timeflies    f          {tf}   A2
1:{ar} A1:{t, f,k1} A2:{tf,k2}
like         fcb      {k2}
{jn,th,t,f,k1,ar}      {jn,th,tf,k2,ar}
1:{jn,th,ar} A1:{t, f,k1} A2:{tf,k2}

April 17, 2007         Iddo Lev, Packed Computation of Exact Meaning Representations                                            45
Packed Derivation
only possible in A1
history   under A1             under A2          packed span
h1        {ar}                 {ar}              1:{ar}
h2        {k1,ar}                                A1:{k1,ar}
h3        {t,f}                                  A1:{t,f}
h4        {t,f,k1,ar}                            A1:{t,f,k1,ar}
h5                             {tf,k2}           A2:{tf,k2}
h6                             {tf,k2,ar}        A2:{tf,k2,ar}
h7        {t,f,k1,ar}          {tf,k2,ar}        1:{ar} A1:{t,f,k1} A2:{tf,k2}
h8        {jn,th}              {jn,th}           1:{jn,th}
h9        {jn,th,t,f,k1,ar}    {jn,thtf,k2,ar}   1:{jn,th,ar} A1:{t,f,k1} A2:{tf,k2}                                     {tf}       {k2}

packed common part
{f}       {t}       {k1}     {ar}
{tf,k2}

{k1,ar}
{t,f}                              A2:{tf,k2,ar}   {jn}
{th}
A1:{t, f,k1,ar}

{jn,th}
1:{ar} A1:{t, f,k1} A2:{tf,k2}

1:{jn,th,ar} A1:{t, f,k1} A2:{tf,k2}

April 17, 2007                  Iddo Lev, Packed Computation of Exact Meaning Representations                                                      46
Packed Derivation
• Two histories with categories A and AB can be combined:
– original algorithm: if their spans are disjoint
– packed algorithm: can combine them in all contexts in which
their spans are disjoint

original combination:
A | S1              AB | S2                   provided S1  S2 = 
B|S                                and S = S1  S2

packed combination:
provided C1  C2  0
C1 | A | PS1       C2 | AB | PS2
and combinable(PS1, PS2, C)
C | B | PS                                and PS = union(C, PS1, PS2)

April 17, 2007            Iddo Lev, Packed Computation of Exact Meaning Representations       47
Packed Derivation
• Two histories with categories A and AB can be combined:
– original algorithm: if their spans are disjoint
– packed algorithm: can combine them in all contexts in which
their spans are disjoint

packed combination:
provided C1  C2  0
C1 | A | PS1       C2 | AB | PS2
and combinable(PS1, PS2, C)
C | B | PS                              and PS = union(C, PS1, PS2)

combinable:           1:{3,4}          1:{5,6,7}              1:{3,4,5,6,7}
combinable:           1:{3},A1:{6,7}   1:{4,5},A2:{6,8}       1:{3,4,5,6},A1:{7},A2:{8}
combinable:           A1:{6},A2:{7}    A1:{6},A2:{8}          A2:{7,8}
non-combinable:       1:{4},A1:{6}     1:{5,6},A2:{4}          (6 is in A1 in both, 4 is in A2 in both)

A1:{4,6}   A2:{4}       A1:{5,6}     A2:{4,5,6}

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations                        48
Packed Derivation
• Two histories with the same category can be packed:
– original algorithm: if their spans are identical
– packed algorithm: if their spans are identical in the shared contexts

can pack:      1:{3,4,5}        1:{3,4,5}       1:{3,4,5}
can pack:      A1:{1},A2:{2}    A2:{2},A3:{3}  A1:{1},A2:{2},A3:{3}
can pack:      A1:{t,f,k1,ar}   A2:{tf,k2,ar}   1:{ar}, A1:{t,f,k1}, A2:{tf,k2}
cannot pack:   1:{5},A1:{6}     1:{5},A2:{7} ({5,6}{5} in A1 , {5}{5,7} in A2))
A1:{5,6}    A2:{5}       A1:{5} A2:{5,7}

{ar}

A2:{tf,k2,ar}
A1:{t, f,k1,ar}

1:{ar} A1:{t, f,k1} A2:{tf,k2}

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations                      49
Packed Derivation
Reconstruction of packed meaning representation:
history   packed span                           meaning
h1        1:{ar}                                l1 : anarrow
h2        A1:{k1,ar}                            like(l1)
h3        A1:{t,f}                              fly(time)
h4        A1:{t,f,k1,ar}                        fly(time,like(l1))
h5        A2:{tf,k2}                            like(timeflies)
h6        A2:{tf,k2,ar}                         like(timeflies,l1)
h7        1:{ar} A1:{t,f,k1} A2:{tf,k2}         A1:fly(time,like(l1)) A2:like(timeflies,l1)
h8        1:{jn,th}                             think(john)
h9        1:{jn,th,ar} A1:{t,f,k1} A2:{tf,k2}

think(john, ●)
A1                           A2
fly(time,like(●))            like(timeflies,●)

anarrow

category graph                                             packed meaning representation
April 17, 2007              Iddo Lev, Packed Computation of Exact Meaning Representations                              50
Packed Derivation
• What if the category graph has cycles?
– Calculate strongly connected components (SCCs) and
the induced directed-acyclic graph (DAG) (+ topological sort)
– In each SCC, run basic algorithm to find all possibilities
– If SCC is simple (X, XX) then optimize:
use as much material as possible before moving out of the cycle

{2} {3} {4}
{1}
XX

X

{1}
category graph              {1,2} {1,3} {1,4}
{1,2,3} {1,2,4} {1,3,4}
{1,2,3,4}
April 17, 2007      Iddo Lev, Packed Computation of Exact Meaning Representations   51
Packed Derivation

[girl [with the telescope]]A2

A2:{wt}
1:{grl}
XX

X

1:{grl}
A1:{grl} A2:{grl,wt}
category graph
1:{grl}, A2:{wt}

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   52
Packed Derivation
Category graph                                                                  {1} e.see(e) : aveart
{2} P.e.P(e) : (aveart)at
1:{8}                     1:{9}                     {3} bill : be
(hvehrt)he             hvehrt
A2:{11}                                                                            {4} xPe.P(e)agent(e,x) : be(aveart)(aveart)
he(gvegrt)(gvegrt)                                                            {5} P.the(P) : (gvegrt)ge
he 1:{8,9}                  {6} x.girl(x) : gvegrt
A2:{8,9,11}                                                                {7} xPe.P(e)theme(e,x) : ge(aveart)(aveart)
(gvegrt)(gvegrt)
{8} P.the(P) : (hvehrt)he
{9} x.tele(x) : hvehrt
{10} A1: yPe.P(e)with(e,y) : he(aveart)(aveart)
(gvegrt)ge       gvegrt                                                           {11} A2: yPx.P(x)with(x,y) : he(gvegrt)(gvegrt)
1:{6},A2:{8,9,11}

A1:{10}
ge        geaetaet                                  1:{3}               heaetaet
beaetaet             be

1:{5,6,7},                    1:{3,4}
A1:{8,9,10}                                Need to calculate
A2:{8,9,11}                                                                                                   strongly-connected
components before
aetaet                                                             1:{2}
aetat
topological sort.
aet
1:{1,3,4,5,6,7,8,9},
A1:{10},A2:{11}            at1:{1,2,3,4,5,6,7,8,9},
packing in a cycle                                                                 A1:{10},A2:{11}

April 17, 2007                        Iddo Lev, Packed Computation of Exact Meaning Representations                                        53
Outline
 Motivation

 From Syntax to Semantics

 Packed Computation

 Conclusion

April 17, 2007   Iddo Lev, Packed Computation of Exact Meaning Representations   54
My Dissertation
• How to map syntactic analysis to meaning representations
• How to compute all meaning representations efficiently
Focus of this talk

• Linguistic analysis of advanced NL constructions using the
above framework
–     anaphora     (interaction with truth conditions)
–     comparatives
–     reciprocals    (each other, one another)
–     same/different
• How to translate meaning representations to
inference representations (FOL)

April 17, 2007          Iddo Lev, Packed Computation of Exact Meaning Representations           55
Summary
• Mapping syntax to exact meaning representations
using Glue Semantics
– More powerful than traditional approach
– Easier for users, more principled than semantic rewrite
rules
• Computing all meaning representations efficiently
– Input: packed syntactic analysis
– Output: packed meaning representation
 Pushing packed ambiguities through the semantics stage

April 17, 2007    Iddo Lev, Packed Computation of Exact Meaning Representations   56
Future Work
• Researchers can use this work as a basis
– Use this in applications
• Logic puzzles, word problems, NLIDB, regulation texts
– Extend this approach to additional NL constructions
• (requires some linguistic research)
– Extend idea of packing to anaphora/plurality and
back-end inference stages
• Some initial work on packed reasoning at PARC
– Extend statistical disambiguation to packed semantic
structures

April 17, 2007       Iddo Lev, Packed Computation of Exact Meaning Representations   57
Thanks
•   Stanley Peters
•   Dick Crouch
•   Chris Manning
•   Mike Genesereth
•   Johan van Benthem

• NLTT group at PARC
• Ivan Sag
• Bill MacCartney, Mihaela Enachescu, Powerset Inc.