Add files using upload-large-folder tool

2b336e2 verified 10 months ago

31.1 kB

	.. Copyright (C) 2001-2023 NLTK Project
	.. For license information, see LICENSE.TXT

	==============================================
	Combinatory Categorial Grammar with semantics
	==============================================

	-----
	Chart
	-----


	>>> from nltk.ccg import chart, lexicon
	>>> from nltk.ccg.chart import printCCGDerivation

	No semantics
	-------------------

	>>> lex = lexicon.fromstring('''
	... :- S, NP, N
	... She => NP
	... has => (S\\NP)/NP
	... books => NP
	... ''',
	... False)

	>>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
	>>> parses = list(parser.parse("She has books".split()))
	>>> print(str(len(parses)) + " parses")
	3 parses

	>>> printCCGDerivation(parses[0])
	She has books
	NP ((S\NP)/NP) NP
	-------------------->
	(S\NP)
	-------------------------<
	S

	>>> printCCGDerivation(parses[1])
	She has books
	NP ((S\NP)/NP) NP
	----->T
	(S/(S\NP))
	-------------------->
	(S\NP)
	------------------------->
	S


	>>> printCCGDerivation(parses[2])
	She has books
	NP ((S\NP)/NP) NP
	----->T
	(S/(S\NP))
	------------------>B
	(S/NP)
	------------------------->
	S

	Simple semantics
	-------------------

	>>> lex = lexicon.fromstring('''
	... :- S, NP, N
	... She => NP {she}
	... has => (S\\NP)/NP {\\x y.have(y, x)}
	... a => NP/N {\\P.exists z.P(z)}
	... book => N {book}
	... ''',
	... True)

	>>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
	>>> parses = list(parser.parse("She has a book".split()))
	>>> print(str(len(parses)) + " parses")
	7 parses

	>>> printCCGDerivation(parses[0])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	------------------------------------->
	NP {exists z.book(z)}
	------------------------------------------------------------------->
	(S\NP) {\y.have(y,exists z.book(z))}
	-----------------------------------------------------------------------------<
	S {have(she,exists z.book(z))}

	>>> printCCGDerivation(parses[1])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	--------------------------------------------------------->B
	((S\NP)/N) {\P y.have(y,exists z.P(z))}
	------------------------------------------------------------------->
	(S\NP) {\y.have(y,exists z.book(z))}
	-----------------------------------------------------------------------------<
	S {have(she,exists z.book(z))}

	>>> printCCGDerivation(parses[2])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	---------->T
	(S/(S\NP)) {\F.F(she)}
	------------------------------------->
	NP {exists z.book(z)}
	------------------------------------------------------------------->
	(S\NP) {\y.have(y,exists z.book(z))}
	----------------------------------------------------------------------------->
	S {have(she,exists z.book(z))}

	>>> printCCGDerivation(parses[3])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	---------->T
	(S/(S\NP)) {\F.F(she)}
	--------------------------------------------------------->B
	((S\NP)/N) {\P y.have(y,exists z.P(z))}
	------------------------------------------------------------------->
	(S\NP) {\y.have(y,exists z.book(z))}
	----------------------------------------------------------------------------->
	S {have(she,exists z.book(z))}

	>>> printCCGDerivation(parses[4])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	---------->T
	(S/(S\NP)) {\F.F(she)}
	---------------------------------------->B
	(S/NP) {\x.have(she,x)}
	------------------------------------->
	NP {exists z.book(z)}
	----------------------------------------------------------------------------->
	S {have(she,exists z.book(z))}

	>>> printCCGDerivation(parses[5])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	---------->T
	(S/(S\NP)) {\F.F(she)}
	--------------------------------------------------------->B
	((S\NP)/N) {\P y.have(y,exists z.P(z))}
	------------------------------------------------------------------->B
	(S/N) {\P.have(she,exists z.P(z))}
	----------------------------------------------------------------------------->
	S {have(she,exists z.book(z))}

	>>> printCCGDerivation(parses[6])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (NP/N) {\P.exists z.P(z)} N {book}
	---------->T
	(S/(S\NP)) {\F.F(she)}
	---------------------------------------->B
	(S/NP) {\x.have(she,x)}
	------------------------------------------------------------------->B
	(S/N) {\P.have(she,exists z.P(z))}
	----------------------------------------------------------------------------->
	S {have(she,exists z.book(z))}

	Complex semantics
	-------------------

	>>> lex = lexicon.fromstring('''
	... :- S, NP, N
	... She => NP {she}
	... has => (S\\NP)/NP {\\x y.have(y, x)}
	... a => ((S\\NP)\\((S\\NP)/NP))/N {\\P R x.(exists z.P(z) & R(z,x))}
	... book => N {book}
	... ''',
	... True)

	>>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
	>>> parses = list(parser.parse("She has a book".split()))
	>>> print(str(len(parses)) + " parses")
	2 parses

	>>> printCCGDerivation(parses[0])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (((S\NP)\((S\NP)/NP))/N) {\P R x.(exists z.P(z) & R(z,x))} N {book}
	---------------------------------------------------------------------->
	((S\NP)\((S\NP)/NP)) {\R x.(exists z.book(z) & R(z,x))}
	----------------------------------------------------------------------------------------------------<
	(S\NP) {\x.(exists z.book(z) & have(x,z))}
	--------------------------------------------------------------------------------------------------------------<
	S {(exists z.book(z) & have(she,z))}

	>>> printCCGDerivation(parses[1])
	She has a book
	NP {she} ((S\NP)/NP) {\x y.have(y,x)} (((S\NP)\((S\NP)/NP))/N) {\P R x.(exists z.P(z) & R(z,x))} N {book}
	---------->T
	(S/(S\NP)) {\F.F(she)}
	---------------------------------------------------------------------->
	((S\NP)\((S\NP)/NP)) {\R x.(exists z.book(z) & R(z,x))}
	----------------------------------------------------------------------------------------------------<
	(S\NP) {\x.(exists z.book(z) & have(x,z))}
	-------------------------------------------------------------------------------------------------------------->
	S {(exists z.book(z) & have(she,z))}

	Using conjunctions
	---------------------

	# TODO: The semantics of "and" should have been more flexible
	>>> lex = lexicon.fromstring('''
	... :- S, NP, N
	... I => NP {I}
	... cook => (S\\NP)/NP {\\x y.cook(x,y)}
	... and => var\\.,var/.,var {\\P Q x y.(P(x,y) & Q(x,y))}
	... eat => (S\\NP)/NP {\\x y.eat(x,y)}
	... the => NP/N {\\x.the(x)}
	... bacon => N {bacon}
	... ''',
	... True)

	>>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
	>>> parses = list(parser.parse("I cook and eat the bacon".split()))
	>>> print(str(len(parses)) + " parses")
	7 parses

	>>> printCCGDerivation(parses[0])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	------------------------------->
	NP {the(bacon)}
	-------------------------------------------------------------------------------------------------------------------------------------------------->
	(S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
	----------------------------------------------------------------------------------------------------------------------------------------------------------<
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	>>> printCCGDerivation(parses[1])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	--------------------------------------------------------------------------------------------------------------------------------------->B
	((S\NP)/N) {\x y.(eat(the(x),y) & cook(the(x),y))}
	-------------------------------------------------------------------------------------------------------------------------------------------------->
	(S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
	----------------------------------------------------------------------------------------------------------------------------------------------------------<
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	>>> printCCGDerivation(parses[2])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	------------------------------->
	NP {the(bacon)}
	-------------------------------------------------------------------------------------------------------------------------------------------------->
	(S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
	---------------------------------------------------------------------------------------------------------------------------------------------------------->
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	>>> printCCGDerivation(parses[3])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	--------------------------------------------------------------------------------------------------------------------------------------->B
	((S\NP)/N) {\x y.(eat(the(x),y) & cook(the(x),y))}
	-------------------------------------------------------------------------------------------------------------------------------------------------->
	(S\NP) {\y.(eat(the(bacon),y) & cook(the(bacon),y))}
	---------------------------------------------------------------------------------------------------------------------------------------------------------->
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	>>> printCCGDerivation(parses[4])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	--------------------------------------------------------------------------------------------------------------------------->B
	(S/NP) {\x.(eat(x,I) & cook(x,I))}
	------------------------------->
	NP {the(bacon)}
	---------------------------------------------------------------------------------------------------------------------------------------------------------->
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	>>> printCCGDerivation(parses[5])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	--------------------------------------------------------------------------------------------------------------------------------------->B
	((S\NP)/N) {\x y.(eat(the(x),y) & cook(the(x),y))}
	----------------------------------------------------------------------------------------------------------------------------------------------->B
	(S/N) {\x.(eat(the(x),I) & cook(the(x),I))}
	---------------------------------------------------------------------------------------------------------------------------------------------------------->
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	>>> printCCGDerivation(parses[6])
	I cook and eat the bacon
	NP {I} ((S\NP)/NP) {\x y.cook(x,y)} ((_var0\.,_var0)/.,_var0) {\P Q x y.(P(x,y) & Q(x,y))} ((S\NP)/NP) {\x y.eat(x,y)} (NP/N) {\x.the(x)} N {bacon}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	------------------------------------------------------------------------------------->
	(((S\NP)/NP)\.,((S\NP)/NP)) {\Q x y.(eat(x,y) & Q(x,y))}
	-------------------------------------------------------------------------------------------------------------------<
	((S\NP)/NP) {\x y.(eat(x,y) & cook(x,y))}
	--------------------------------------------------------------------------------------------------------------------------->B
	(S/NP) {\x.(eat(x,I) & cook(x,I))}
	----------------------------------------------------------------------------------------------------------------------------------------------->B
	(S/N) {\x.(eat(the(x),I) & cook(the(x),I))}
	---------------------------------------------------------------------------------------------------------------------------------------------------------->
	S {(eat(the(bacon),I) & cook(the(bacon),I))}

	Tests from published papers
	------------------------------

	An example from "CCGbank: A Corpus of CCG Derivations and Dependency Structures Extracted from the Penn Treebank", Hockenmaier and Steedman, 2007, Page 359, https://www.aclweb.org/anthology/J/J07/J07-3004.pdf

	>>> lex = lexicon.fromstring('''
	... :- S, NP
	... I => NP {I}
	... give => ((S\\NP)/NP)/NP {\\x y z.give(y,x,z)}
	... them => NP {them}
	... money => NP {money}
	... ''',
	... True)

	>>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
	>>> parses = list(parser.parse("I give them money".split()))
	>>> print(str(len(parses)) + " parses")
	3 parses

	>>> printCCGDerivation(parses[0])
	I give them money
	NP {I} (((S\NP)/NP)/NP) {\x y z.give(y,x,z)} NP {them} NP {money}
	-------------------------------------------------->
	((S\NP)/NP) {\y z.give(y,them,z)}
	-------------------------------------------------------------->
	(S\NP) {\z.give(money,them,z)}
	----------------------------------------------------------------------<
	S {give(money,them,I)}

	>>> printCCGDerivation(parses[1])
	I give them money
	NP {I} (((S\NP)/NP)/NP) {\x y z.give(y,x,z)} NP {them} NP {money}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	-------------------------------------------------->
	((S\NP)/NP) {\y z.give(y,them,z)}
	-------------------------------------------------------------->
	(S\NP) {\z.give(money,them,z)}
	---------------------------------------------------------------------->
	S {give(money,them,I)}


	>>> printCCGDerivation(parses[2])
	I give them money
	NP {I} (((S\NP)/NP)/NP) {\x y z.give(y,x,z)} NP {them} NP {money}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	-------------------------------------------------->
	((S\NP)/NP) {\y z.give(y,them,z)}
	---------------------------------------------------------->B
	(S/NP) {\y.give(y,them,I)}
	---------------------------------------------------------------------->
	S {give(money,them,I)}


	An example from "CCGbank: A Corpus of CCG Derivations and Dependency Structures Extracted from the Penn Treebank", Hockenmaier and Steedman, 2007, Page 359, https://www.aclweb.org/anthology/J/J07/J07-3004.pdf

	>>> lex = lexicon.fromstring('''
	... :- N, NP, S
	... money => N {money}
	... that => (N\\N)/(S/NP) {\\P Q x.(P(x) & Q(x))}
	... I => NP {I}
	... give => ((S\\NP)/NP)/NP {\\x y z.give(y,x,z)}
	... them => NP {them}
	... ''',
	... True)

	>>> parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)
	>>> parses = list(parser.parse("money that I give them".split()))
	>>> print(str(len(parses)) + " parses")
	3 parses

	>>> printCCGDerivation(parses[0])
	money that I give them
	N {money} ((N\N)/(S/NP)) {\P Q x.(P(x) & Q(x))} NP {I} (((S\NP)/NP)/NP) {\x y z.give(y,x,z)} NP {them}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	-------------------------------------------------->
	((S\NP)/NP) {\y z.give(y,them,z)}
	---------------------------------------------------------->B
	(S/NP) {\y.give(y,them,I)}
	------------------------------------------------------------------------------------------------->
	(N\N) {\Q x.(give(x,them,I) & Q(x))}
	------------------------------------------------------------------------------------------------------------<
	N {\x.(give(x,them,I) & money(x))}

	>>> printCCGDerivation(parses[1])
	money that I give them
	N {money} ((N\N)/(S/NP)) {\P Q x.(P(x) & Q(x))} NP {I} (((S\NP)/NP)/NP) {\x y z.give(y,x,z)} NP {them}
	----------->T
	(N/(N\N)) {\F.F(money)}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	-------------------------------------------------->
	((S\NP)/NP) {\y z.give(y,them,z)}
	---------------------------------------------------------->B
	(S/NP) {\y.give(y,them,I)}
	------------------------------------------------------------------------------------------------->
	(N\N) {\Q x.(give(x,them,I) & Q(x))}
	------------------------------------------------------------------------------------------------------------>
	N {\x.(give(x,them,I) & money(x))}

	>>> printCCGDerivation(parses[2])
	money that I give them
	N {money} ((N\N)/(S/NP)) {\P Q x.(P(x) & Q(x))} NP {I} (((S\NP)/NP)/NP) {\x y z.give(y,x,z)} NP {them}
	----------->T
	(N/(N\N)) {\F.F(money)}
	-------------------------------------------------->B
	(N/(S/NP)) {\P x.(P(x) & money(x))}
	-------->T
	(S/(S\NP)) {\F.F(I)}
	-------------------------------------------------->
	((S\NP)/NP) {\y z.give(y,them,z)}
	---------------------------------------------------------->B
	(S/NP) {\y.give(y,them,I)}
	------------------------------------------------------------------------------------------------------------>
	N {\x.(give(x,them,I) & money(x))}


	-------
	Lexicon
	-------

	>>> from nltk.ccg import lexicon

	Parse lexicon with semantics

	>>> print(str(lexicon.fromstring(
	... '''
	... :- S,NP
	...
	... IntransVsg :: S\\NP[sg]
	...
	... sleeps => IntransVsg {\\x.sleep(x)}
	... eats => S\\NP[sg]/NP {\\x y.eat(x,y)}
	...
	... and => var\\var/var {\\x y.x & y}
	... ''',
	... True
	... )))
	and => ((_var0\_var0)/_var0) {(\x y.x & y)}
	eats => ((S\NP['sg'])/NP) {\x y.eat(x,y)}
	sleeps => (S\NP['sg']) {\x.sleep(x)}

	Parse lexicon without semantics

	>>> print(str(lexicon.fromstring(
	... '''
	... :- S,NP
	...
	... IntransVsg :: S\\NP[sg]
	...
	... sleeps => IntransVsg
	... eats => S\\NP[sg]/NP {sem=\\x y.eat(x,y)}
	...
	... and => var\\var/var
	... ''',
	... False
	... )))
	and => ((_var0\_var0)/_var0)
	eats => ((S\NP['sg'])/NP)
	sleeps => (S\NP['sg'])

	Semantics are missing

	>>> print(str(lexicon.fromstring(
	... '''
	... :- S,NP
	...
	... eats => S\\NP[sg]/NP
	... ''',
	... True
	... )))
	Traceback (most recent call last):
	...
	AssertionError: eats => S\NP[sg]/NP must contain semantics because include_semantics is set to True


	------------------------------------
	CCG combinator semantics computation
	------------------------------------

	>>> from nltk.sem.logic import *
	>>> from nltk.ccg.logic import *

	>>> read_expr = Expression.fromstring

	Compute semantics from function application

	>>> print(str(compute_function_semantics(read_expr(r'\x.P(x)'), read_expr(r'book'))))
	P(book)

	>>> print(str(compute_function_semantics(read_expr(r'\P.P(book)'), read_expr(r'read'))))
	read(book)

	>>> print(str(compute_function_semantics(read_expr(r'\P.P(book)'), read_expr(r'\x.read(x)'))))
	read(book)

	Compute semantics from composition

	>>> print(str(compute_composition_semantics(read_expr(r'\x.P(x)'), read_expr(r'\x.Q(x)'))))
	\x.P(Q(x))

	>>> print(str(compute_composition_semantics(read_expr(r'\x.P(x)'), read_expr(r'read'))))
	Traceback (most recent call last):
	...
	AssertionError: `read` must be a lambda expression

	Compute semantics from substitution

	>>> print(str(compute_substitution_semantics(read_expr(r'\x y.P(x,y)'), read_expr(r'\x.Q(x)'))))
	\x.P(x,Q(x))

	>>> print(str(compute_substitution_semantics(read_expr(r'\x.P(x)'), read_expr(r'read'))))
	Traceback (most recent call last):
	...
	AssertionError: `\x.P(x)` must be a lambda expression with 2 arguments

	Compute type-raise semantics

	>>> print(str(compute_type_raised_semantics(read_expr(r'\x.P(x)'))))
	\F x.F(P(x))

	>>> print(str(compute_type_raised_semantics(read_expr(r'\x.F(x)'))))
	\F1 x.F1(F(x))

	>>> print(str(compute_type_raised_semantics(read_expr(r'\x y z.P(x,y,z)'))))
	\F x y z.F(P(x,y,z))