Lecture 13: Natural Language Semantics I

Transcription

1 Comp24412 Symbolic AI Lecture 13: Natural Language Semantics I Ian Pratt-Hartmann Room KB ipratt@cs.man.ac.uk

2 Outline A notation for functions Natural language semantics Prolog implementation

3 Some functions defined on the integers: λx[2x] = { 0,0, 1,2, 2,4,...} λx[x 2 ] = { 0,0, 1,1, 2,4, 3,9,...} λx[(x +4) 3 ] = { 0,64, 1,125, 2,216,...}

4 Some more functions λx[x] = λx[x +0] = { 0,0, 1,1, 2,2,...} λx[x +1] = { 0,1, 1,2, 2,3,...} λx[x +2] = { 0,2, 1,3, 2,4,...} Functions with functions as values λy[λx[x +y]] = { 0,{ 0,0, 1,1,...}, 1,{ 0,1, 1,2,...}, 2,{ 0,2, 1,3,...},...}

5 Applying functions: (λx[2x] 3) = 2.3 = 6 (λx[x 2 ] 5) = 5 2 = 25 (λx[(x +4) 3 ] 2) = (2+4) 3 = 216 (λy[λx[x +y]] 2) = λx[x +2] ((λy[λx[x +y]] 2) 3) = (λx[x +2] 3) = 2+3 = 5

6 Note: some authors (actually, just Blackburn and Bos) use notation, thus: (λx[2x])@3 = 2.3 = 6 (λx[x 2 ])@5 = 5 2 = 25 (λy[λx[x +y]])@2)@3 = λx[x +2]@3 = 2+3 = 5

7 Higher-order functions take functions as arguments. Here is a function which takes function on numbers, and applies it to 5: λf[(f 5)] Then we can compute (λf[(f 5)] λx[x +1]) = (λx[x +1] 5) = 5+1 = 6. Notice that this procedure is completely mechanical.

8 Functions with other domains and ranges λx[(prime x)] = { 0,F, 1,F, 2,T, 3,T, 4,F,...} Let {john,mary,...,jane} be a set of individuals λx[(boy x)] = { john,t, mary,f,..., jane,f } and of course λx[λy[((kissed x) y))]] = { john,{ john,f, mary,t,..., jane,f }, mary,{ john,t, mary,f,..., jane,f },... jane,{ john,f, mary,f,..., jane,f } }

9 Again, we can have higher-order functions over such domains. the property of being a property possessed by Mary: λp[(p mary)] the property of being a property possessed by every girl: λp[ x((girl x) (p x))] the property of being a property possessed by some boy: λp[ x((boy x) (p x))]

10 The lambda calculus features two operations on lambda-expressions: α-conversion: renaming of bound variables: λx[ϕ(x)] = λy[ϕ(y)] where y is a variable not occurring free in ϕ β-reduction: applying lambda functions to their arguments: (λx[ϕ(x)] ψ) = ϕ(ψ) where ψ is an expression of the appropriate type. Here, the expression on the left-hand-side is called the redex and the expression on the right, the reduct.

11 Outline A notation for functions Natural language semantics Prolog implementation

12 Consider the (old-style) grammar rules: S NP,VP NP PropN VP Vi and lexicon PropN Mary Vi coughed

13 This grammar assigns the sentence Mary coughed the structure: S NP PropN VP Vi Mary coughed

14 Let us now assign meanings as follows: [[ NP Mary]] = λp[(p mary)] [[ Vi coughed]] = λx[(coughed x)] And let us augment the grammar rules with semantic information: S/(ϕ ψ) NP/ϕ,VP/ψ VP/ϕ Vi/ϕ

15 These meaning-assignments and grammar rule tell us that [[ S Mary coughed]] = ([[ NP Mary]] [[ VP coughed]]) = (λp[p(mary)] λx[(coughed x)]) = (coughed mary)

16 We can illustrate this process diagrammatically: S coughed(mary) NP VP λp[p(mary)] λx[coughed(x)] Mary V λx[coughed(x)] coughed

17 Similarly, consider the sentence Mary kissed John, with structure S NP VP PropN Mary V kissed NP PropN John

18 Let us assign meanings as follows: [[ NP John]] = λp[(p john)] [[ NP Mary]] = λp[(p mary)] [[ V kissed]] = λs[λx[s(λy[((kissedx)y))])]] And let us augment the usual VP rule with semantic information: VP/(ϕ ψ) V/ϕ,NP/ψ

19 This leads to the following meaning computation: S kissed(mary,john) = λp[p(mary)](λx[kissed(x, john)]) NP λp[p(mary)] VP λx[kissed(x, john)] Mary V λs[λx[s(λy[kissed(x, y)] NP λp[p(john)] kissed John

20 Outline A notation for functions Natural language semantics Prolog implementation

21 Lambda-expressions can easily be encoded in Prolog Lambda-calculus: λx[(boy x)] Prolog: lbd(x, boy(x)) Lambda-calculus: λp[λq[ x((p x) (q x))]] Prolog: lbd(p,lbd(q,forall(x,px -> qx)))

22 I have written a predicate var replace/2 that performs α-conversion: λx[(f (g ((h x) x)))] = λx [(f (g ((h x ) x )))]?- var_replace(lbd(x,f(g(h(x,x)))),l). L = lbd(x2, f(g(h(x2, x2)))) ; No λp[λq[ x((p x) (q x))]] = λp [λq [ x ((p x ) (q x ))]] var_replace(lbd(p, lbd(q, exists(x, (p@x & q@x)))),l). L = lbd(p1, lbd(q1, exists(x1, p1@x1&q1@x1))) ; No

23 var_replace(x,x):- atomic(x),!. var_replace(x,result):- X =.. [Head,Var,Expr], variable_binder(head),!, gensym(var,result_var), substitute(var,result_var,expr,result_expr1), var_replace(result_expr1,result_expr), Result =.. [Head,Result_var,Result_expr]. var_replace(x,result):- X =.. XList, maplist(var_replace,xlist,resultlist), Result =.. ResultList. variable_binder(lbd). variable_binder(forall). variable_binder(exists).

24 We define the substitution predicate as: % Expression B is the result of substituting % an occurrence of expression Y for each % occurrence of expression X in expression A. substitute(x,y,x,y):-!. substitute(_x,_y,a,a):- atomic(a),!. substitute(x,y,a,b):- A =.. A_list, maplist(substitute(x,y),a_list,b_list), B =.. B_list.

25 Similarly, I have written a predicate beta/2 that implements β-reduction assuming that there are no variable clashes: ( λq[ λp[ x(q(x) p(x))]] λx 1 [boy(x 1 )]) = λp[ x(boy(x) p(x beta(lbd(q, lbd(p, forall(x, (q@x -> p@x))))@(lbd(x1,boy@x1)),l). L = lbd(p, forall(x, boy@x->p@x)); No

26 Now beta is implemented as follows: beta(exp,exp):- atomic(exp),!. substitute(v,exp,f_body,result1), beta(result1,result). beta(exp,result):- Exp=..ExpList, maplist(beta,explist,resultlist), Result=..ResultList. To think about: does the order in which the redexes are reduced matter? To think about: does the process even terminate?

27 Now for the clever bit We can transcribe the augmented grammar rules S/ϕ(ψ) NP/ϕ, VP/ψ VP/ϕ(ψ) V/ϕ, NP/ψ as the Prolog DCG rules s(ssem) --> np(npsem), vp(vpsem), {var_replace(npsem,npsem1), vp(vpsem) --> v(vsem), np(npsem), {var_replace(vsem,vsem1),

28 And we can encode the meaning-assignments [[ NP John]] = λp[(p john)] [[ NP Mary]] = λp[(p mary)] [[ V kissed]] = λs[λx[s(λy[((kissed x) y)])]] as the the Prolog DCG rules np(lbd(p,p@john)) --> [john]. np(lbd(p,p@mary)) --> [mary]. v(lbd(s,lbd(x,s@lbd(y,kissed(x,y))))) --> [kissed].

29 The result is:?- s(ssem,[john,kissed,mary],[]). SSem = kissed(john, mary) ; Prolog has performed the calculation carried out above

30 Consider the sentence Every boy loves some girl. We assign meanings as follows: [[ Det every]] = λqλp[ x((q x) (p x)] [[ Det some]] = λqλp[ x((q x) (p x)] [[ V loves]] = λs[λx[(s λy[((loves x) y)])]] [[ N boy]] = λx[(boy x)] [[ N girl]] = λx[(girl x)] And we augment the usual NP rule with semantic information: NP/(ϕ ψ) Det/ϕ,N/ψ

31 We encode all of this as Prolog DCG rules in the usual way: np(npsem) --> det(detsem), n(nsem), {var_replace(detsem,detsem1), & --> [some]. -> --> [every]. (loves(x,y)))))) --> [loves]. n(lbd(x,boy(x)))--> [boy]. n(lbd(x,girl(x)))--> [girl].

32 Lo and behold:?- s(ssem,[every,boy,loves,some,girl],[]), pp(ssem). (x11)(boy(x11) => (Ex2)(girl(x2) & loves(x11, x2))) which, when we change the fonts a bit, becomes x 11 (boy(x 11 ) x 2 (girl(x 2 ) loves(x 11,x 2 )))

33 Similarly:?- s(ssem,[some,girl,loves,some,girl],[]), pp(ssem). (Ex41)(girl(x41) & (Ex5)(girl(x5) & loves(x41, x5))) which, when we change the fonts a bit, becomes Wow! x 41 (girl(x 41 ) x 5 (girl(x 5 ) loves(x 41,x 5 )))

34 Summary: The Lambda calculus: α-conversion β-reduction Semantics: Meaning assignment to terminals Semantically augmented grammar Computation of sentence meaning Transcription into Prolog Illustrations