ling 388 language and computers n.
Download
Skip this Video
Download Presentation
LING 388 Language and Computers

Loading in 2 Seconds...

play fullscreen
1 / 30

LING 388 Language and Computers - PowerPoint PPT Presentation


  • 47 Views
  • Uploaded on

LING 388 Language and Computers. Lecture 20 11/6 /03 Sandiway FONG. Administrivia. Next Tuesday (11th) Veterans’ Day Today’s Lecture Homework 3 review Help with Homework 4 Next time … We start a brand-new topic known as Shallow Parsing

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 'LING 388 Language and Computers' - uta


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
ling 388 language and computers

LING 388Language and Computers

Lecture 20

11/6/03

Sandiway FONG

administrivia
Administrivia
  • Next Tuesday (11th)
    • Veterans’ Day
  • Today’s Lecture
    • Homework 3 review
    • Help with Homework 4
  • Next time …
    • We start a brand-new topic known as Shallow Parsing
      • We’ll begin with Part-of-speech (POS) tagging, stemming …
exercise 1 part b encoding the idiom kick the bucket

np

vp

v

john

died

Exercise 1 Part (B): Encoding the idiom kick the bucket
  • Add a DCG rule to encode the idiomatic meaning of John kicked the bucket, i.e.

s

?- s(X,[john,kicked,the,bucket],[])

X = s(np(john),vp(v(died)))

  • Hint: see how the terminal string the ball was encoded in Lecture 10

np --> [the,ball].

sample dcg
Sample DCG
  • s(s(X,Y)) --> np(X), vp(Y).
  • np(np(X,Y)) --> det(X,Num), common_noun(Y,Num).
  • np(np(X)) --> proper_noun(X).
  • vp(vp(X)) --> intransitive_verb(X).
  • vp(vp(X,Y)) --> transitive_verb(X), np(Y).
  • common_noun(n(man),sg) --> [man].
  • common_noun(n(men),sg) --> [men].
  • proper_noun(john) --> [john].
  • det(det(the),_) --> [the]. det(det(a),sg) --> [a].
  • intransitive_verb(v(ran)) --> [ran].
  • transitive_verb(v(saw)) --> [saw].
exercise 4 part a implementing every and some
Exercise 4 Part (A): Implementing every and some
  • Want parses:
    • s(forall(X,man(X)),vp(v(likes),np(john))))
    • s(exists(X,men(X)),vp(v(like),np(n(beer))))
  • for
    • Every man likes John
    • Some men like beer
exercise 4 part a implementing every and some1
Exercise 4 Part (A): Implementing every and some
  • NP rules:
    • np(np(X,Y)) --> quantifier(X,Num), common_noun(Y,Num).
    • quantifier(q(every),sg) --> [every].
    • quantifier(q(some),_) --> [some].
    • common_noun(n(man),sg) --> [man].
    • common_noun(n(men),pl) --> [men].
  • Solution:
    • Write one rule specialized for every and another for some
exercise 4 part a implementing every and some2
Exercise 4 Part (A): Implementing every and some
  • Case 1: every
    • np(np(X,Y)) --> quantifier(X,Num), common_noun(Y,Num).
    • quantifier(q(every),sg) --> [every].
    • common_noun(n(man),sg) --> [man].
  • Parsing every man will produce the following series of variable bindings:

np(np(X,Y)) --> quantifier(X,Num), common_noun(Y,Num).

quantifier(q(every),sg)

common_noun(n(man),sg)

every

man

exercise 4 part a implementing every and some3
Exercise 4 Part (A): Implementing every and some
  • Perform a partial substitution; instantiate every:
    • np(np(X,Y)) -->
      • quantifier(q(every),Num),
      • common_noun(n(N),Num).
  • Note:
    • NP rule is now particular to sequences every N
    • I.e. NP rule won’t fire for other NP sequences like:
      • some men
      • the cat
      • John
exercise 4 part a implementing every and some4
Exercise 4 Part (A): Implementing every and some
  • Substitute forall for np:
    • np(forall(X,Y)) -->
      • quantifier(q(every),Num),
      • common_noun(n(N),Num).
  • Finally, add code in {…} to generate Y from N:
    • np(forall(X,Y)) -->
      • quantifier(q(every),Num),
      • common_noun(n(N),Num),
      • {Y=..[N,X]}.
  • The same implementation strategy works also for some and exists(X,N(X)) …
key concepts
Key Concepts
  • Use partial variable substitution
      • … to customize a rule
  • We can build f(X) where f cannot be determined statically,

i.e. at the time we specify the grammar rule

by …

      • using Prolog built-in univ (=..), and
      • the DCG rule out-call mechanism {…}
logic and negation in prolog
Logic and Negation in Prolog
  • Filter 1:
    • All variables must be bound by an operator
  • Implementation:
    • \+ (variable(X,F), var(F))
      • variable/2 is an np(x) finder
      • F bound when lx can be found
  • Question:
    • Why are we implementing a positive condition using negation (\+)?
logic and negation in prolog1
Logic and Negation in Prolog

s

np

vp

np

lambda

v

np

n

det

x

s

hissed at

x

cat

the

np

vp

  • *The cat that John saw hissed at

john

v

np

saw

x

logic and negation in prolog2
Logic and Negation in Prolog
  • Example:
    • All tomatoes are red
  • Define predicates:

tomato(X)

red(X)

  • Condition:
    • ?- tomato(X), red(X).
      • holds if there exists some X such that X is a tomato and X is red
      • Doesn’t check all the tomatoes in the box
      • Hence, query does not guarantee that all the tomatoes in the box are red
logic and negation in prolog3
Logic and Negation in Prolog
  • Example:
    • All tomatoes are red
  • Equivalent condition:
    • It cannot be the case that there exists some tomato and that tomato is not red
  • Implementation:
    • ?- \+ ( tomato(X), \+ red(X)).
      • holds if it is not the case that there exists some X such that X is a tomato and X is not red
      • Guarantees that all the tomatoes in the box are red
logic and negation in prolog4
Logic and Negation in Prolog
  • Basic Quantifier Conversion Rules:
      • "x p(x) <=> Ø$x Øp(x)
      • Ø$x p(x) <=> "x Øp(x)
  • Examples:
    • "X tomato(X), red(X)
    • <=> Ø$X tomato(X), \+ red(X)
  • Prolog variables?
    • By default, existentially quantified ($)
logic and negation in prolog5
Logic and Negation in Prolog
  • Filter 1:
    • All variables must be bound by an operator
  • Conversion:
    • There must not exist a variable that is not bound by an operator
  • Implementation:
    • \+ (variable(X,F), var(F))
      • variable/2 is an np(x) finder
      • F bound when lx can be found
implementing the exactly one condition
Implementing the Exactly One Condition
  • In Exercise 5 …
    • Filter 2:
      • All operators must bind exactly one variable
    • Implementation:
      • filter2(X) :- operator(X).
    • Predicate:
      • operator(X)
        • holds if X contains a lx.Y with less than two variables in Y
implementing the exactly one condition1
Implementing the Exactly One Condition
  • Operator/1 calls predicate lt2vars/2:
    • lt2vars(X,F)
      • holds if there are less than two variables in X
      • F is bound to one if there is one variable in X
    • We’ll need to impose either that:
      • F == one or
      • \+ var(F)

to the output of lt2vars/2 to implement the condition for exactly one variable

implementing the universally quantified condition
Implementing the Universally Quantified Condition
  • Not done yet …
    • Filter 2:
      • All operators must bind exactly one variable
    • Implementation:
      • filter2(X) :- operator(X).
    • Predicate:
      • operator(X)
        • holds if X contains a lx.Y with less than two variables in Y
        • I.e. if in X $ lx.Y with less than two variables in Y
implementing the universally quantified condition1
Implementing the Universally Quantified Condition
  • Filter 2:
    • All operators must bind exactly one variable
  • So we must convert this to an existentially quantified condition
  • Equivalently:
    • In X, it cannot be the case that operator(X) holds and the number of variables bound is not one
overlapping non overlapping clauses
Overlapping/Non-Overlapping Clauses
  • Question:
    • For tree-walkers, why do we sometimes want overlapping clauses, i.e. have more than one applicable clause, and why sometimes we don’t?
  • Example:
    • operator/1 is overlapping
    • lt2vars/2 is non-overlapping
case 1 non overlapping clauses
Case 1: Non-Overlapping Clauses
  • lt2vars(np(x),F) :-
    • var(F), F = one.
  • lt2vars(X,F) :-
    • X =.. [_,A1,A2],
    • lt2vars(A1,F),
    • lt2vars(A2,F).
  • lt2vars(X,F) :-
    • \+ X = np(x),
    • X =.. [_,A],
    • lt2vars(A,F).
  • lt2vars(X,_) :- atom(X).
  • Unary branching structure:

np(x)

matches two clauses

blocks np(x)

Want only one match!

case 1 non overlapping clauses1

lt2vars(np(x),F) :-

    • var(F), F = one.
  • lt2vars(X,F) :-
    • X =.. [_,A1,A2],
    • lt2vars(A1,F),
    • lt2vars(A2,F).
  • lt2vars(X,F) :-
    • \+ X = np(x),
    • X =.. [_,A],
    • lt2vars(A,F).
  • lt2vars(X,_) :- atom(X).
Case 1: Non-Overlapping Clauses

np(x)

  • Need to block the lower clause from applying
    • it does not set F, and otherwise
    • ?- lt2vars(X,F), var(F).
    • will succeed when X has, say, three np(x)s

[Upper clause will reject 3 np(x)s, but lower clause will pass it.]

case 2 overlapping clauses
Case 2: Overlapping Clauses
  • operator(lambda(x,Y)):-
    • lt2vars(Y,_).
  • operator(X) :-
    • X =.. [_,A1,_],
    • operator(A1).
  • operator(X) :-
    • X =.. [_,_,A2],
    • operator(A2).
  • operator(X) :-
    • X =.. [F,A],
    • operator(A).
  • Binary branching structure:

lambda(x,_)

matches three clauses

Want multiple matches!

case 2 overlapping clauses1
Case 2: Overlapping Clauses

lambda(x,_)

  • operator(lambda(x,Y)):-
    • lt2vars(Y,_).
  • operator(X) :-
    • X =.. [_,A1,_],
    • operator(A1).
  • operator(X) :-
    • X =.. [_,_,A2],
    • operator(A2).
  • operator(X) :-
    • X =.. [F,A],
    • operator(A).
  • operator/1 is a lx finder
  • We want it to be able to find and test all lx structures within a phrase structure
  • ?- operator(X). will succeed once for each lx in X
case 2

s

vp

np

Case 2

first lx

np

v

mary

np

lambda

hit

x

s

det

n

np

vp

the

man

np

lambda

v

np

n

det

x

s

hissed at

x

cat

the

np

vp

  • *Mary hit the man that the cat that John saw Mary hissed at

john

v

np

saw

mary

case 21

s

vp

np

Case 2

first lx

np

v

mary

np

lambda

hit

x

s

det

n

np

vp

the

man

np

lambda

v

np

n

det

x

s

hissed at

x

cat

the

np

vp

  • *Mary hit the man that the cat that John saw Mary hissed at

john

v

np

saw

mary

key concept
Key Concept
  • We need to restrict or use overlap as appropriate
    • Because of Prolog’s search strategy
      • i.e. if a clause fails during a query, Prolog will look for another way to succeed