The NL2KR system Chitta Baral, Juraj Dzifcak, Kanchan Kumbhare, and Nguyen H. Vo School of Computing, Informatics, and Decision Systems Engineering, Arizona State University, Tempe, Arizona, USA chitta@asu.edu, Juraj.Dzifcak@asu.edu, krkumbha@asu.edu, Nguyen.H.Vo@asu.edu Abstract. In this paper we will describe the NL2KR system that trans- lates natural language sentences to a targeted knowledge representation formalism. The system starts with an initial lexicon and learns mean- ing of new words from a given set of examples of sentences and their translations. We will describe the first release of our system with several examples. Keywords: Natural Language Understanding, Lambda Calculus, Knowl- edge Representation 1 Introduction and Motivation Our approach to understanding natural language involves translating natural language text to formal statements in an appropriate knowledge representation language so that a reasoning engine can reason with the translated knowledge and give a response, be it an answer, a clarifying question or an action. To translate natural language text to a formal statement we propose to use the compositional method of Montague [1] where the translation (or meaning) of words are given as lambda calculus formulas and the meaning of phrases and sentences are obtained by composing the meaning of the constituent words. The challenge in doing this is in coming up with appropriate lambda calculus expressions for each word. The challenging aspects in this are: (a) the number of words may be huge, (b) the lambda calculus expression (or meaning) of some words are too complicated for humans to come up with it, and (c) the lambda calculus expressions for the words are target language specific; so it is not a one time affair like compiling traditional dictionaries. To address these challenges we use an inverse lambda algorithm [2] that computes the meaning of a word/phrase G when the meaning of the word/phrase H and the phrase GH (or HG) is known. The NL2KR system uses an initial lexicon containing some words and their meanings and a set of training corpus containing sentences in natural language and their translations to learn new meanings of words. The system then uses the new learned lexicon to translate new sentences. In this paper, we would like to give an overview of the NL2KR system and examples of using it. 2 Chitta Baral, Juraj Dzifcak, Kanchan Kumbhare, and Nguyen H. Vo 2 Overview Shown below in Fig. 1 is the architecture of the NL2KR system. It has two sub- parts which depend on each other (1) NL2KR-L for learning and (2) NL2KR-T for translating. Fig. 1. Architecture of the NL2KR system: NL2KR-T on the left and NL2KR-L on the right The NL2KR-L sub-part takes an initial lexicon consisting of some words and their meanings in terms of λ-calculus expressions & a set of training sentences and their target formal representations as input. It then uses a Combinato- rial Categorical Grammar (CCG) parser to construct the parse trees. Next, the learning sub-part of the system uses Inverse-λ and Generalization algorithms to learn meanings of newly encountered words, which are not present in the initial lexicon, and adds them to the lexicon. A parameter learning method is then used to estimate a weight for each lexicon entry (word, its syntactic category and meaning) such that the joint probability of the sentences in the training set getting translated to their given formal representation is maximized. The re- sult of NL2KR-L is the final lexicon, which contains a larger set of words, their meanings and their weights. Once the training component finishes its job, the translation sub-part (NL2KR- T) uses this updated lexicon and translates sentences using the CCG parser. Since words can have multiple meanings and their associated λ-calculus expres- sions, weights assigned to each lexical entry in the lexicon helps in deciding the more likely meaning of a word in the context of a sentence. 3 Using NL2KR The latest version of NL2KR system can be downloaded from http://nl2kr.engineering.asu.edu. It can be run on Linux (64 bit) and OS-X. The NL2KR system 3 3.1 Third Party Software Used by NL2KR The current version of NL2KR uses the following libraries and tools developed by others: – Scripting language Python (version ≥ 2.6) – AspCcgTk version 0.3 1 – Stanford Log-linear Part-Of-Speech Tagger 2 (version 3.1.5) – Oracle Java (version ≥ 1.6) – ASP grounder and solver: gringo (version 3.x), clasp (version 2.x) and clingo (version 3.x) 3 3.2 Installation guide The NL2KR package contains a readme file and a zipped file which contains – AspCcgTk – Jar file and models of Stanford Log-linear Part-Of-Speech Tagger – Jar file and configurations for NL2KR – Gringo, clasp and clingo After unzipping the package, the instruction in the readme file directs how to install NL2KR. 3.3 Files/Folders in the package Following is a brief list of important files/folders in the package: – README: Installation instruction and examples of how to use NL2KR. – NL2KR.jar: NL2KR’s classes packed in a jar file. – config.properties: Default configuration of the NL2KR system. – install.sh: Script to install NL2KR. – ccgParser.sh: Script to get a CCG parse tree of a given sentence. – Generalization.sh: Script that gives generalized meanings of a word. – Inverse.sh: Script to compute the inverse using the inverse lambda algo- rithms. – Lambda.sh: Script to do application operation, given a function and an argument in λ-calculus. – NL2KR-L.sh: Script to run the NL2KR-L sub-part. – NL2KR-T.sh: Script to run the NL2KR-T sub-part. – RunConfiguration: Example inputs of the preceding scripts. – resources: Folder containing AspCcgTk package, gringo, clasp and clingo. – examples: Folder containing examples in various domains for NL2KR-L and NL2KR-T. 1 http://www.kr.tuwien.ac.at/staff/former staff/ps/aspccgtk 2 http://nlp.stanford.edu/software/tagger.shtml 3 http://potassco.sourceforge.net/ 4 Chitta Baral, Juraj Dzifcak, Kanchan Kumbhare, and Nguyen H. Vo 3.4 Executing the scripts To execute any of the scripts one needs to go to the NL2KR’s root directory and run ./ < script name > < R u nC o n f i g u r a t i o n file > [ Optional params ] where script name is the name of one of the six scripts (e.g. ./Lambda.sh), RunConfiguration file contains corresponding parameters for the script, and optional parameters are for the Java Virtual Machine (JVM) to execute the module that corresponds to the script. For learning and testing large dataset with NL2KR-L or NL2KR-T, it is recommended to provide more memory for the JVM and enable garbage collection if needed (i.e. Use -Xmx and -XX:- UseGCOverheadLimit). 3.5 Lambda application To use the lambda application script, the function and the argument of the lambda application need to be provided. For example, the following snippet in the RunConfiguration file specifies that we need to apply the argument #x.x@mia to the function #y.#x.loves(x, y) (note: # is for λ). function =# y .# x . loves (x , y ) argument =# x . x@mia The output of the lambda application is f unction@argument. According to lambda application, the y variable is replaced by #x.x@mia and the result is #x.loves(x, #x0.x0@mia), where x in the argument is renamed to x0. Running the lambda application script with the preceding configuration yields the output: Function =# y .# x . loves (x , y ) Argument =# x . x@mia Result = # x . loves (x ,# x0 . x0 @ mia ) However, in the following configuration, the argument cannot be applied to the function since there is no free variable in the function. function = loves (x , y ) argument = # x . x @ mia The output thus would be Function = loves (x , y ) Argument = # x . x @ mia Cannot apply the argument # x . x @ mia to the function loves (x , y ) 3.6 Inverse application Given two lambda expressions g and h, the lambda application gives us f = g@h or f = h@g. But sometime, we have only f and g and we need to find h. The inverse application allow us to calculate the lambda expression h so that f = g@h or f = h@g. More details about the inverse application can be found in [2]. For inverse application, we need to provide the parent (lambda expression f ), the right child (r) or the left child (l). Given one child, the module will calculate the other child so that f = l@r. The NL2KR system 5 In the first example below, since there does not exist a lambda expression h (right child) so that mia@h = #x.loves(x, mia), the inverse algorithm re- turns right child expression = null. However, when mia is the right child, inverse lambda returns Lef tchild = #x1.#x.loves(x, x1) because #x1.#x.loves(x, x1)@mia = #x.loves(x, mia). In case the CCG parse tree specifies that the meaning of “Mia” must be in the left child, using left child as #x.x@mia instead of mia will do the trick and let us have the same right child: #x1.#x.loves(x, x1). Example 1. Input: parent =# x . loves (x , mia ) left_child = mia Output: Parent = # x . loves (x , mia ) Left child = mia Right child = null Example 2. Input: parent =# x . loves (x , mia ) right_child = mia Output: Parent = # x . loves (x , mia ) Right child = mia Left child = # x1 .# x . loves (x , x1 ) Example 3. Input: parent =# x . loves (x , mia ) left_child =# x . x @ mia Output: Parent = # x . loves (x , mia ) Left child =# x . x @ mia Right child = # x1 .# x . loves (x , x1 ) 3.7 Generalization The inverse lambda module is not always adequate to learn new meanings of words when we lack meaning of words that will allow us to use the inverse lambda module. To address that we have developed a generalization module in NL2KR system, where the generalization technique described in [2] is imple- mented. For example, if we want to find the meaning of the word plays with the category (S\N P )/N P using generalization, we can use the lexical entry (eats, (S\N P )/N P , λy.λx.eats(x, y)) in the lexicon, where the category of the word eats is same as that of the word plays. The generalization module will add a new lexical entry (plays, (S\N P )/N P , λy.λx.plays(x, y)) to the lexicon. The input of the generalization module is the file path for lexicon (existing dictionary) and a new word, which we want to generalize. Following is an illustration of the use of generalization with the RunConfiguration file having the following: 6 Chitta Baral, Juraj Dzifcak, Kanchan Kumbhare, and Nguyen H. Vo lexicon =./ examples / sample / dictionary . txt word = Mia ccg = N where dictionary.txt contains Vincent N vincent Vincent N # x . vincent ( x ) takes ( S \ NP ) / NP # w . # z . ( w@ # x . takes (z , x ) ) plane N # x . plane ( x ) 5 boxer N # x . boxer ( x ) fights S \ NP # x . fight ( x ) In this case, the word Mia can be obtained by generalization from the words Vincent, plane and boxers, each of category N (meaning noun); and the output is New lexical items learned through G enerali zation : Mia [N] # x . mia ( x ) Mia [N] mia We can restrict generalization by modifying the config.properties file. For example, adding the following snippet to config.properties will skip the general- ization process for NP and N categories, and generalization for the words: on, of, by and in. G E N E R A L I Z A T I O N _ D _ E X C L I S T =[ NP ] ,[ N ] G E N E R A L I Z A T I O N _ D _ P R E P O S I T I O N L I S T = on , of , by , in 3.8 CCG parser The input of the CCG parser module is the sentence we want to parse and an optional path of the file containing the words and their additional categories we want to use. The parser will parse the input sentence and output its CCG parse tree. Our CCG parser is based on ASP ccgT k [3] with some modifications such as our use of the Stanford Part-Of-Speech tagger [4] instead of the C&C Part-Of-Speech tagger [5] to improve accuracy. Following is an example snippet of the RunConfiguration file. sentence = ’ Every boxer walks ’ syntaxFile =./ examples / sample / syntax . txt where syntax.txt contains takes ( S \ NP ) / NP Every ( S /( S \ NP ) ) / NP Some ( S /( S \ NP ) ) / NP walks S \ NP 5 fights S \ NP loves ( S \ NP ) / NP The output of the CCG parser is a parse tree of the sentence “Every boxer walks” in ASP format as follows nl2kr_token ( t1 , " Every " , "( S /( S \ NP ) ) / NP " , 1) . nl2kr_token ( t2 , " boxer " , " NP " , 2) . nl2kr_token ( t3 , " walks " , " S \ NP " , 3) . nl2kr_token ( t4 , " Every boxer " , " S /( S \ NP ) " ,1) . 5 nl2kr_token ( t5 , " Every boxer walks " , " S " , 1) . n l 2 k r _ c h i l d _ l e f t ( t4 , t1 ) . n l 2 k r _ c h i l d _ r i g h t ( t4 , t2 ) . n l 2 k r _ c h i l d _ l e f t ( t5 , t4 ) . n l 2 k r _ c h i l d _ r i g h t ( t5 , t3 ) . 10 n l 2 k r _ v a l i d _ r o o t N o d e ( t5 ) . The NL2KR system 7 The predicate nl2kr valid rootN ode is used to specify the root node of the parse tree (corresponds to the whole sentence). nl2kr token is used to specify nodes in the tree and nl2kr child lef t, nl2kr child right are for the left child and the right child of a node. The four atoms of nl2kr token are respectively the node ID, the corresponding phrase, its CCG category and its starting position in the sentence. 3.9 NL2KR-L: the learning module of NL2KR To run the learning module NL2KR-L we need to set the initial lexicon file path, the override file for syntax categories (optional), the training data file and the output dictionary file path (optional) in the RunConfiguration file of the NL2KR-L. Following is an example snippet of the RunConfiguration file. Ldata =./ examples / sample / train . txt Ldictionary =./ examples / sample / dictionary . txt Lsyntax =./ examples / sample / syntax . txt Loutput =./ examples / sample / d i c t i o n a ry _ t r a i n . out For example, the preceding snippet specifies that: the training data is in ./exam- ples/train.txt, the initial lexicon is in ./examples/sample/dictionary.txt, and the override syntax categories are in ./examples/sample/syntax.txt. The override syntax categories will be used in CCG parsing step as showed in the previous subsection. If it is not specified, the output dictionary is saved as dictionary train.out in ./output folder. The training data file contains the training sentences and their formal repre- sentation such as: Some boxer walks EX . ( boxer ( X ) ^ walk ( X ) ) John takes a plane EX . ( plane ( X ) ^ takes ( john , X ) ) John walks walk ( john ) In the above, EX denotes ∃X. The initial lexicon contains words and the their meanings that we already know: John N john takes ( S \ NP ) / NP # w . # z . ( w@ # x . takes (z , x ) ) plane N # x . plane ( x ) boxer N # x . boxer ( x ) 5 fights S \ NP # x . fight ( x ) The NL2KR-L sub-part learns the new meanings of words in multiple itera- tions. It stops when it cannot learn any new word. Below we give the output of the script with example inputs. We start with some snippets of the running output in the following. From line 5 to 9, NL2KR-L was checking if it has the meaning of Some boxer and walks. It then learned the meaning of walks by generalization. From line 15 to 19, NL2KR-L was trying to learn the meaning of Some boxer given the meaning of walks and the meaning of the whole sentence Some boxer walks from the training data. Using inverse lambda, it figured out that the meaning of Some boxer is #x1.EX.boxer(X) ∧ x1@X. NL2KR-L did not go further to the meaning of “some” because the meaning “boxer” of boxer was not helpful. 8 Chitta Baral, Juraj Dzifcak, Kanchan Kumbhare, and Nguyen H. Vo However, using the second parse tree where the meaning #x.boxer(X) of boxer is used, NL2KR-L can get the meaning of some (line 42-49) : #x2.#x1.EX.x2@X∧ x1@X. ****** Learning lexicon ... ... Processing sentence number 1 Processing Parse Tree 1 5 Word : Some boxer walks sem :: null Both children do not have current lambda expression : Some boxer , walks Generalizing for leafs with no expected lambda : walks New lexical item Learned by Expansion : walks ////[ S \ NP ]////# x . walk ( x ) ... 10 Processing sentence number 1 Processing Parse Tree 1 Word : Some boxer walks sem :: null 15 Applying inverse : EX . boxer ( X ) ^ walk ( X ) # x . walk ( x ) INVERSE_L Tried : Some boxer walks ( H ) = EX . boxer ( X ) ^ walk ( X ) walks ( G ) = # x . walk ( x ) Some boxer ( F ) = # x1 . EX . boxer ( X ) ^ x1 @ X 20 Word : walks sem ::# x . walk ( x ) Word : Some boxer sem :: null Applying inverse : # x1 . EX . boxer ( X ) ^ x1 @ X boxer INVERSE_L Tried : Some boxer ( H ) = # x1 . EX . boxer ( X ) ^ x1 @ X 25 boxer ( G ) = boxer Some ( F ) = null Generalizing for leafs with no expected lambda : Some Generalizing for leafs with no expected lambda : boxer Word : boxer sem :: boxer 30 Word : Some sem :: null Processing Parse Tree 2 Word : Some boxer walks sem :: null 35 Applying inverse : EX . boxer ( X ) ^ walk ( X ) # x . walk ( x ) INVERSE_L Tried : Some boxer walks ( H ) = EX . boxer ( X ) ^ walk ( X ) walks ( G ) = # x . walk ( x ) Some boxer ( F ) = # x1 . EX . boxer ( X ) ^ x1 @ X 40 Word : walks sem ::# x . walk ( x ) Word : Some boxer sem :: null Applying inverse : # x1 . EX . boxer ( X ) ^ x1 @ X # x . boxer ( x ) INVERSE_L Tried : Some boxer ( H ) = # x1 . EX . boxer ( X ) ^ x1 @ X 45 boxer ( G ) = # x . boxer ( x ) Some ( F ) = # x2 .# x1 . EX . x2 @ X ^ x1 @ X Word : boxer sem ::# x . boxer ( x ) Word : Some sem :: null New lexicon Learned : Some ////[( S /( S \ NP ) ) / NP ]////# x2 .# x1 . EX . x2 @ X ^ x1 @ X At the end of the learning phase, parameter estimation is run to assign the weights for each meaning of words. NL2KR-L then uses those meanings to check if they are enough to translate the training sentences correctly. ****** Evaluation on training set ... Processing training sentence : Some boxer walks Predicted Result : EX . boxer ( X ) ^ walk ( X ) 5 Correct Prediction Processing training sentence : John takes a plane Predicted Result : EX . plane ( X ) ^ takes ( john , X ) Correct Prediction The NL2KR system 9 10 ... Following is the output lexicon learned with the example inputs mentioned earlier. Each row contains a word, its CCG category, its meaning and the as- sociated weight. Compared to the initial dictionary, we can see that NL2KR-L learned 14 more word meanings. Note that some words such as likes and eats are in the “syntax.txt”. Some [( S /( S \ NP ) ) / NP ] # x2 .# x1 . EX . x2 @ X ^ x1 @ X 0.0074364278 fight [ S \ NP ] # x . fight ( x ) 0.01 boxer [ N ] # x . boxer ( x ) 0.060000002 boxer [ N ] boxer -0.041248113 5 a [ NP / N ] # x4 .# x2 . EX . x4 @ X ^ x2 @ X 0.009887816 John [ NP ] john 0.0073314905 John [ N ] john 0.01 eats [( S \ NP ) / NP ] # w .# z . w @ # x . eats (z , x ) 0.01 fights [ S \ NP ] # x . fights ( x ) 0.01 10 fights [ S \ NP ] # x . fight ( x ) 0.01 takes [( S \ NP ) / NP ] # w .# z . w @ # x . takes (z , x ) 0.01 walks [ S \ NP ] # x . walks ( x ) -0.08722576 walks [ S \ NP ] # x . walk ( x ) 0.10615976 plane [ N ] # x . plane ( x ) 0.059950046 15 plane [ N ] plane -0.03995005 likes [( S \ NP ) / NP ] # w .# z . w @ # x . likes (z , x ) 0.01 flies [ S \ NP ] # x . fly ( x ) 0.01 flies [ S \ NP ] # x . flies ( x ) 0.01 loves [( S \ NP ) / NP ] # w .# z . w @ # x . loves (z , x ) 0.01 3.10 NL2KR-L in the Geoquery domain In this subsection, we present an example of using NL2KR-L for the GEO- QUERY4 domain. GEOQUERY uses a Prolog based language to query a database with geographical information about the U.S. The input of NL2KR-L is specified in the RunConfiguration file as: Ldata =./ examples / geoquery / train . txt Ldictionary =./ examples / geoquery / dictionary . txt Lsyntax =./ examples / geoquery / syntax . txt Loutput = where ./examples/geoquery/train.txt contains How large is texas answer ( X ) ^ size (B , X ) ^ const (B , sid , texas ) How high is mountmckinley answer ( X ) ^ elevation (B , X ) ^ const (B , pid , mountmckinley ) How big is massachusetts answer ( X ) ^ size (B , X ) ^ const (B , sid , massachusetts ) How long is riogrande answer ( X ) ^ len (B , X ) ^ const (B , rid , riogrande ) 5 How tall is mountmckinley answer ( X ) ^ elevation (B , X ) ^ const (B , pid , mountmckinley ) ./examples/geoquery/dictionary.txt contains How S/S # x . answer ( X ) ^ x@X texas NP # x . const (x , sid , texas ) mountmckinley NP # x . const (x , pid , mountmckinley ) massachusetts NP # x . const (x , sid , massachusetts ) 5 riogrande NP # x . const (x , rid , riogrande ) is ( S \ NP ) / NP #y. #x.x @ y and ./examples/geoquery/syntax.txt contains 4 http://www.cs.utexas.edu/users/ml/geo.html 10 Chitta Baral, Juraj Dzifcak, Kanchan Kumbhare, and Nguyen H. Vo How S/S texas NP mountmckinley NP massachusetts NP 5 riogrande NP is ( S \ NP ) / NP rivers NP large NP is ( S \ NP ) / NP 10 high NP big NP long NP the NP / NP How S /( S \ NP ) 15 long S \ NP tall NP colorado NP arizona NP After the learning module is executed, 15 more word meanings were learned by NL2KR-L and the result is: is [( S \ NP ) / NP ] # y .# x . x @ y -0.0015125279 texas [ NP ] # x . const (x , sid , texas ) 0.07666666 texas [ NP ] # x . const (x , rid , texas ) -0.023256822 texas [ NP ] # x . const (x , pid , texas ) -0.023256822 5 riogrande [ NP ] # x . const (x , pid , riogrande ) -0.02315781 riogrande [ NP ] # x . const (x , rid , riogrande ) 0.07646726 riogrande [ NP ] # x . const (x , sid , riogrande ) -0.02315781 mountmckinley [ NP ] # x . const (x , sid , mountmckinley ) -0.055226557 mountmckinley [ NP ] # x . const (x , pid , mountmckinley ) 0.14075616 10 mountmckinley [ NP ] # x . const (x , rid , mountmckinley ) -0.055226557 massachusetts [ NP ] # x . const (x , rid , massachusetts ) -0.023190754 massachusetts [ NP ] # x . const (x , sid , massachusetts ) 0.0765336 massachusetts [ NP ] # x . const (x , pid , massachusetts ) -0.023190754 long [ NP ] # x3 .# x1 . len (B , x1 ) ^ x3 @ B 0.010111484 15 How [ S / S ] # x . answer ( X ) ^ x @ X 0.009999999 high [ NP ] # x3 .# x1 . elevation (B , x1 ) ^ x3 @ B 0.010112147 big [ NP ] # x3 .# x1 . size (B , x1 ) ^ x3 @ B 0.010111821 tall [ NP ] # x . const (x , rid , tall ) -0.014923776 tall [ NP ] # x . const (x , pid , tall ) -0.014923776 20 tall [ NP ] # x3 .# x1 . elevation (B , x1 ) ^ x3 @ B 0.084677815 tall [ NP ] # x . const (x , sid , tall ) -0.014923776 large [ NP ] # x3 .# x1 . size (B , x1 ) ^ x3 @ B 0.010112498 3.11 NL2KR-T: the translation sub-part of NL2KR Similar to NL2KR-L, in the RunConfiguration file of NL2KR-T, we need to set the lexicon file path, the override file for syntax categories(optional), and the testing data file as given below: Tdata =./ examples / sample / test . txt Tdictionary =./ output / d i c t i o n a r y _ t r a i n . out Tsyntax =./ examples / sample / syntax . txt For example, the preceding snippet specifies that: the testing data is in ./ex- amples/sample/test.txt, the lexicon is in ./output/dictionary train.out, and the override syntax categories are in ./examples/sample/syntax.txt. The lexicon should be the lexicon learned by NL2KR-L. The content of ./examples/sample/test.txt is Mia sleeps sleep ( mia ) John catches a bus EX . ( bus ( X ) ^ catches ( john , X ) ) The NL2KR system 11 Running the NL2KR-T script with the inputs specified above, we have the following output where John catches a bus is translated to EX. (bus(X) ∧ catches(john, X)) as expected. ****** Parsing Sentences ... ... Parsing test sentence : John catches a bus Expected Repr esentat ion : EX . ( bus ( X ) ^ catches ( john , X ) ) 5 Generalizing bus = [ bus : [ N ] : # x . bus ( x ) , bus : [ N ] : bus ] Generalizing catches = [ catches : [( S \ NP ) / NP ] : # w .# z . w @ # x . catches (z , x ) ] Predicted Result : EX . bus ( X ) ^ catches ( john , X ) Correct Prediction ... Note that the expected translation in “test.txt” is optional. Without it, the evaluation is not correct but NL2KR-T still gives its results. 4 Conclusion and Future Work In this work, we presented the NL2KR system, which is used for translating natural language to a formal representation. The input of the NL2KR system are training sentences and their formal representation; and an initial lexicon of some known meanings of words. NL2KR system will try to learn the meaning of others words from the training data. We presented six scripts to execute several modules of NL2KR and show how to use them through examples. In the future, we plan to make NL2KR more scalable and add more features to the NL2KR system such as (1) automatically constructing the initial lexicon and (2) using more knowledge such as word sense to select the correct meaning of words. References 1. Montague, R.: English as a Formal Language. In Thomason, R.H., ed.: Formal Philosophy: Selected Papers of Richard Montague. Yale University Press, New Haven, London (1974) 188–222 2. Baral, C., Dzifcak, J., Gonzalez, M.A., Zhou, J.: Using Inverse lambda and Gener- alization to Translate English to Formal Languages. CoRR abs/1108.3843 (2011) 3. Lierler, Y., Schüller, P.: Parsing Combinatory Categorial Grammar via Planning in Answer Set Programming. In Erdem, E., Lee, J., Lierler, Y., Pearce, D., eds.: Correct Reasoning. Volume 7265 of Lecture Notes in Computer Science., Springer (2012) 436–453 4. Toutanova, K., Klein, D., Manning, C.D., Singer, Y.: Feature-rich part-of-speech tagging with a cyclic dependency network. In: NAACL ’03: Proceedings of the 2003 Conference of the North American Chapter of the Association for Computational Linguistics on Human Language Technology, Morristown, NJ, USA, Association for Computational Linguistics (2003) 173–180 5. Clark, S., Curran, J.R.: Parsing the WSJ using CCG and log-linear models. In: ACL ’04: Proceedings of the 42nd Annual Meeting on Association for Computational Linguistics, Morristown, NJ, USA, Association for Computational Linguistics (2004) 103