LCS Database Documentation
(Dorr, 2001)

To download the LCS Database, click here. Please read the copyright notice and documentation below. References to relevant papers are also included.


(c) 2000, 2001 University of Maryland, All Rights Reserved

This file contains the LCS Database, produced by researchers in the Computational Linguistics and Information Processing Laboratory, University of Maryland, directed by Bonnie J. Dorr, copyright (c) University of Maryland, 2000, 2001. Any work, published or unpublished, based in whole or in part on the use of this resource should acknowledge the "LCS Database" by Bonnie J. Dorr at the University of Maryland. The author would appreciate being informed of such work or other significant uses of this database:

Distribution of this database is permissible as long as this copyright notice above and the description and acknowledgements below stay in tact.

The "LCS Database" contains Lexical conceptual Structures built by hand by Dorr in 1994, organized into semantic classes that are a reformulated version of those in Beth Levin (1993) English Verb Classes and Alternations (EVCA), Part 2. For a contrastive classification, see Levin's index here. The LCS Database was hand-tagged with WordNet on a per-class basis, using the 1.6 version of WordNet (Fellbaum, 1998). The resulting database was further extended to include 26 new classes (Dorr, 1996, 1997), and adding 3000 WordNet-tagged verbs. Additional contributions to this database were made in collaboration with Douglas Jones (Dorr and Jones, 1999) and the classes were further refined by Mari Olsen (Olsen et al. 1997) so that they contain semantic representation that indicate verbal telicity patterns. Levin's original database contained 3024 verbs in 192 classes numbering between 9.1 and 57---a total of 4186 verb entries. The augmented database contains 4432 verbs in 492 classes with more specific numbering (e.g., ``51.3.2.a.ii'') and additional class numbers for new classes (between 000 and 026)---a total of 11000 verb entries. The verbs in the "LCS Database" is alternately referred to as EVCA+ in some recent publications (Green et al, 2001a, 2001b).

The LCS Database has been used extensively in the dissertation work of Scott Thomas and Nizar Habash. Relevant citations are given below.

We would like to thank Julie Dahmer, Charles Lin, and David Woodard for their WordNet annotations which we used here. We would also like to thank Karen Kohl for her annotations of the verbs in Part 1 of Levin's work, which we used to give hints for annotating these verbs of Part 2.


Dorr, Bonnie J., "Large-Scale Dictionary Construction for Foreign Language Tutoring and Interlingual Machine Translation," Machine Translation, 12:4, pp. 271--322, 1997. PDF

Dorr, Bonnie J. and Mari Broman Olsen, "Multilingual Generation: The Role of Telicity in Lexical Choice and Syntactic Realization," Machine Translation, 11:1-3, pp. 37--74, 1996. PDF

Dorr, Bonnie J. and Douglas Jones, "Acquisition of Semantic Lexicons: Using Word Sense Disambiguation to Improve Precision," in Evelyn Viegas (Ed), Breadth and Depth of Semantic Lexicons, Kluwer Academic Publishers, Norwell, MA, pp. 79--98, 2000. PDF

Fellbaum, Christiane, WordNet: An Electronic Lexical Database, MIT Press, 1998. WordNet link

Green, Rebecca, Lisa Pearl, Bonnie J. Dorr, and Philip Resnik, "Lexical Resource Integration across the Syntax-Semantics Interface," Proceedings of the NAACL Workshop on WordNet and Other Lexical Resources: Applications, Extensions and Customizations, Carnegie Mellon University, Pittsburg, PA, pp. 71--76, 2001. PDF

Green, Rebecca, Lisa Pearl, Bonnie J. Dorr, and Philip Resnik, "Mapping WordNet Senses to a Lexical Database of Verbs," Proceedings of the 39th Annual Meeting of the Association for Computational Linguistics, Toulouse, France, pp. 244--251, 2001. PDF

Levin, Beth, "English Verb Classes and Alternations: A Preliminary Investigation", University of Chicago Press, Chicago, IL, 1993.

Olsen, Mari Broman, Bonnie J. Dorr, and Scott C. Thomas, "Toward Compact Monotonically Compositional Interlingua Using Lexical Aspect," Proceedings of the Workshop on Interlinguas in MT, MT Summit, San Diego, CA, pp. 33--44, October, 1997. PDF

An Introduction to Lexical Conceptual Structure

an extract from Generation from Lexical Conceptual Structures. (Traum and Habash, 2000)

Lexical Conceptual Structure is a compositional abstraction with language-independent properties that transcend structural idiosyncrasies (Jackendoff 1983, Jackendoff 1990, Jackendoff 1996). This representation has been used as the interlingua of several projects such as UNITRAN (Dorr 1993) and MILT (Dorr 1997).

An LCS is a directed graph with a root. Each node is associated with certain information, including a type, a primitive and a field. The type of an LCS node is one of Event, State, Path, Manner, Property or Thing. There are two general classes of primitives: closed class or structural primitive (e.g., CAUSE, GO, BE, TO) and open class primitives or constants (e.g., reduce+ed, textile+, slash+ingly). suffixes such as +, +ed, +ingly are markers of the open class of primitives. primitives have a Examples of fwields include Locational, Possessional, Identificational.

An LCS captures the semantics of a lexical item through a combination of semantic structure (specified by the shape of the graph and its structural primitives and fields) and semantic content (specified through constants). The semantic structure of a verb is something the verb inherits from its Levin verb class whereas the content comes from the specific verb itself. So, all the verbs in the "Cut Verbs - Change of State" class have the same semantic structure but vary in their semantic content (for example, chip, cut, saw, scrape, slash and scratch).

The lexicon entry or Root LCS (RLCS) of one sense of the Chinese verb xue1_jian3 is as follows:

(act_on loc (* thing 1) (* thing 2)
        ((* [on] 23) loc (*head*) (thing 24)) 
        (cut+ingly 26) 

The top node in the RLCS has the structural primitive ACT_ON in the locational field. Its subject is a star-marked LCS (or an unspecified LCS) with the restriction that a filler LCS be of the type thing. The number "1" in that node specifies the thematic role: in this case, agent. The second child node is in an argument position and needs to be of type thing too. The number "2" stands for theme. The last two children specify the manner of the locational act_on, that is "cutting in a downward manner". The RLCS for nouns are generally much simpler since they include only one root node with a primitive. For instance (US+) or (quota+).

The meaning of complex phrases is captured through a CLCS - composed LCS. This is constructed "composed" from several RLCSes corresponding to individual words. In the composition process that starts with a parsed tree of the input sentence, all the obligatory positions in a RLCS are filled with other RLCSes. For example, the three RLCSes we have seen already can compose to give the CLCS for the sentence: United states cut down (the) quota

(act_on lo c (us+) (quota+)
       ((* [on] 23) loc (*head*) (thing 24)) 
        (cut+ingly 26) 

CLCS structures can be composed of different sorts of RLCS structures, corresponding to different words. A CLCS can also be decomposed on the generation side in different ways depending on the RLCSes of the lexical items in the target language. For example, the CLCS above will match a single verb and two arguments when generated in Chinese (regardless of the input language). But it will match four lexical items in English: cut, US, quota, and down, since the RLCS for the verb "cut" in the English lexicon does not include the modifier down:

(act_on loc (* thing 1) (* thing 2)
       ((* [on] 23) loc (*head*) (thing 24)) 
        (cut+ingly 26))

The rest of the examples in this paper will refer to the slightly more complex CLCS of the sentence The United States unilaterally reduced the China textile export quota below, which roughly corresponds to ``The United States caused the quota (modified by china, textile and export) to go identificationally (or transform) towards being at the state of being reduced.'' This LCS is presented without all the additional features for sake of clarity. Also, it is actually one of eight possible LCS compositions produced by the analysis component from the input Chinese sentence.

(cause (us+)
   (go ident (quota+ (china+) 
       (to ident (quota+ (china+) 
          (at ident (quota+ (china+) 
  (with instr (*HEAD*) nil)

Additional Relevant Publications

Generation from Lexical Conceptual Structures.
Traum, David and Nizar Habash.Workshop on Applied Interlinguas, ANLP-2000. Seattle, WA
A Thematic Hierarchy for Efficient Generation from Lexical Conceptual Structures.
Bonnie J. Dorr. Nizar Habash. David Traum. October 1998. University of Maryland Institute for Advanced Computer Studies. Department of Computer Science, University of Maryland.
Lexical Selection for Cross-Language Applications: Combining LCS with WordNet.
Bonnie J. Dorr. Maria Katsova. October 1998. University of Maryland Institute for Advanced Computer Studies. Department of Computer, University of Maryland.
Toward a Lexicalized Grammar for Interlinguas
C. Voss and B. Dorr, Journal of Machine Translation, 10:1, pp. 139-180, 1995.
From Syntactic Encodings to Thematic Roles: Building Lexical Entries for Interlingual MT
B. Dorr, J. Garman, and A. Weinberg, Journal of Machine Translation, 9:3, pp. 71-100, 1995.
Machine Translation Divergences: A Formal Description and Proposed Solution
B. Dorr, Computational Linguistics Journal, 20:4, pp. 597-633, 1994.
Concept Based Lexical Selection
B.J. Dorr, C.R. Voss, E. Peterson, and M. Kiker, in Proceedings of the AAAI-94 fall symposium on Knowledge Representation for Natural Language Processing in Implemented Systems, New Orleans, LA, 1994.
The Use of Lexical Semantics in Interlingual Machine Translation
B.J. Dorr, Journal of Machine Translation, 7:3, pp. 135-193, 1992.


Verbs in our database are grouped together in classes, each represented by a Lexical Conceptual Structure (LCS). These were derived from Levin (1993) and subsequently modified, mainly by subdivision. The LCS is an event structure representation, corresponding to the well-formedness conditions, etc., given below.


To determine whether a constituent is an argument or a modifier, we use linguistic principles, including classifying subjects as arguments. Other constituents that modify the verb are also arguments. In the case of "John put [the book] [on the table]" both phrasal constituents are arguments: the event of "putting" involves moving a book to a location. In contrast, modifiers take the entire predicate as an argument: in "John put the book on the table [on Tuesday]" the temporal location characterizes the entire event of putting the book on the table (and not simply a part of the event, as does the physical location "on the table").

Arguments are selected by verbs, and can be either optional or obligatory (see below). Argument selection is associated with primitive/field combinations.


The following fields are used, based on Jackendoff (see references in Dorr 1993):

LOCational: Jackendoff (main spatial field)
IDENTificational: Jackendoff (properties)
POSSessional: Jackendoff (possession)
TEMPoral: Jackendoff (time)
EXISTential: Jackendoff (existence)
CIRCumstantial: Jackendoff (circumstances)
COMMunicative: New field *
PERCeptual: New field (See Dorr 1993)
INSTRumental: New field (See Dorr 1993)
INTENTional: "for the purpose of" or "for a property or characteristic" or "for searched item" (Covers most (all?) uses of "for" that are not benefactive (John baked a cake for Mary)

*This field was created to capture fact that "tell" is different from verbs like "talk" and "speak", which incorporate the theme (ie the message). For "talk" and "speak" (in the perceptual field), the incorporated theme is aspectually unbounded, so that one can say "Mary talked to John for an hour" (cf. "Mary told them stories for an hour"). In English, all the COMM verbs, however, allow the themes (incorporated or not) to surface as "about X", as in "Mary talked to John about X"; they differ in whether the goal uses "to" or not.


Events, States, Positions and Paths are closed class primitives.

1. Events and States The ACT primitive selects only one argument; all others select two arguments. The argument types are listed in parentheses (separated by a comma) below. The first (or only) argument of any primitive is called the logical subject. This argument may be an agent of CAUSE/LET/CAUSE_EXCHANGE, a theme/experiencer of ORIENT, GO, GO-EXT, STAY, BE, or an agent/theme of ACT. The second argument is what is called the "reference object" and generally occurs (multiply) further down under a position or path/position.

No Field: ({Thing | Event | State}, {Event | State})
LET NIL (Thing, Event) ;; Mary dropped the book
LET NIL (Thing, State) ;; Mary weighed the box
LET NIL (Event, Event) ;; The party allowed Mary to cry
LET NIL (Event, State) ;; The party allowed Mary to be happy
LET NIL (State, Event) ;; Mary's knowledge allowed her solve crimes
LET NIL (State, State) ;; Mary's knowledge allowed her to be happy
CAUSE NIL (Thing, Event) ;; Mary threw the box
CAUSE NIL (Thing, State) ;; Mary suspended the box
CAUSE NIL (Event, Event) ;; The party caused Mary to cry
CAUSE NIL (Event, State) ;; the party caused Mary to be happy
CAUSE NIL (State, Event) ;; Mary's knowledge caused her to cry
CAUSE NIL (State, State) ;; Mary's knowledge caused her to be happy
CAUSE_EXCHANGE NIL (Thing, Event) ;; Mary sold the house

Locational Field: ({Thing | Event | State}, {Thing | Event}) (Motion/location in space. See Jackendoff)
ORIENT LOC (Thing, Thing) ;; The sign pointed toward DC
ORIENT LOC (Thing, Event) ;; The sign pointed toward the party
GO LOC (Thing, Thing) ;; The man went to DC
GO LOC (Thing, Event) ;; The man went to the meeting
GO LOC (Event, Thing) ;; John moved the meeting to the conference room
GO LOC (Event, Event) ;; The party moved to the meeting
GO LOC (State, Thing) ;; John transferred his knowledge to the students
GO LOC (State, Event) ;; John transferred his knowledge to the party (?)
GO-EXT LOC (Thing, Thing) ;; The road extended from NY to CA
GO-EXT LOC (Thing, Event) ;; The road extended from the conference
GO-EXT LOC (Event, Thing) ;; The party extended from 34th St to 35th St
GO-EXT LOC (Event, Event) ;; The party ranged from festivity to disaster(?)
GO-EXT LOC (State, Thing) ;; His knowledge ranged from math to chemistry
GO-EXT LOC (State, Event) ;; His knowledge extended from meeting to meeting
STAY LOC (Thing, Thing) ;; The man stayed at home
STAY LOC (Thing, Event) ;; The man stayed at the party
STAY LOC (Event, Thing) ;; The party remained in his home
STAY LOC (Event, Event) ;; The party remained at the meeting
STAY LOC (State, Thing) ;; His knowledge remained in his head
STAY LOC (State, Event) ;; His knowledge remained at the meeting (?)
BE LOC (Thing, Thing) ;; The man was at home
BE LOC (Thing, Event) ;; The man was at the party
BE LOC (Event, Thing) ;; The party was in his home
BE LOC (Event, Event) ;; The party was at the meeting
BE LOC (State, Thing) ;; His knowledge was in his head
BE LOC (State, Event) ;; His knowledge was at the meeting (?)

ACT LOC (Thing) ;; John exercised
ACT_ON LOC (Thing, Thing) ;; John swept the floor
PATH_ACT LOC (Thing, Event) ;; John turned his back at the commotion

Possessional Field: ({Thing | Event | State}, Thing)
GO POSS (Thing, Thing) ;; Mary received the book
GO POSS (Event, Thing) ;; The city received the attack
GO POSS (State, Thing) ;; John received knowledge from his teacher (Note: the above GO POSS examples have a surface order different from the LCS arguments structure. This is accomplished by means of the :INT/:EXT markers described below).
STAY POSS (Thing, Thing) ;; Mary kept the book
STAY POSS (Event, Thing) ;; Bill retained his good hearing
STAY POSS (State, Thing) ;; Bill retained his knowledge about cars
BE POSS (Thing, Thing) ;; The box weighs 10 pounds
BE POSS (Event, Thing) ;; The party totaled 10 dollars
BE POSS (State, Thing) ;; He had a tremendous knowledge about cars

Temporal Field: ({Event | State}, {Time | Event | State})
GO-EXT Temp (Event, Time) ;; The meeting went from 9 to 10
GO-EXT Temp (Event, Event);; The meeting went from dinner to the party
GO-EXT Temp (Event, State);; The meeting went from nomination to Election
GO-EXT Temp (State, Time) ;; His knowledge went from year to year
GO-EXT Temp (State, Event);; His knowledge went from dinner to the party (?)
GO-EXT Temp (State, State);; His knowledge went from nomination to Election
GO TEMP (Event, Time) ;; The meeting went from 9 to 5
GO TEMP (Event, Event) ;; The meeting went until the party
GO TEMP (Event, State) ;; The meeting went until he was tired
GO TEMP (State, Time) ;; John's beliefs went from morning to night (?)
GO TEMP (State, Event) ;; John's beliefs went until the party (?)
GO TEMP (State, State) ;; John's beliefs went until he was tired (?)
STAY TEMP (Event, Time) ;; The meeting remained at 9:00
STAY TEMP (Event, Event) ;; The meeting lasted until the party
STAY TEMP (Event, State) ;; The meeting lasted until John's acknowledgement
STAY TEMP (State, Time) ;; His beliefs lasted until this year
STAY TEMP (State, Event) ;; His beliefs lasted until this year's party
STAY TEMP (State, State) ;; His beliefs lasted until John's acknowledgement
BE TEMP (Event, Time) ;; The meeting was at 9:00
BE TEMP (Event, Event) ;; The meeting was during Passover
BE TEMP (Event, State) ;; The meeting was during the Election
BE TEMP (State, Time) ;; The nomination was at 9:00
BE TEMP (State, Event) ;; The nomination was during the party
BE TEMP (State, State) ;; The nomination was before the Election

Identificational Field: ({Thing | Event | State}, {Thing | Event | Property})
GO IDENT (Thing, Thing) ;; The pumpkin changed into a coach
GO IDENT (Thing, Event) ;; The article became an attack on women
GO IDENT (Thing, Property) ;; The article became outrageous
GO IDENT (Event, Thing) ;; The party turned into a mess
GO IDENT (Event, Event) ;; The party turned into a revolt
GO IDENT (Event, Property) ;; The party turned ugly
GO IDENT (State, Thing) ;; John's beliefs became an issue
GO IDENT (State, Event) ;; John's beliefs became an attack
GO IDENT (State, Property) ;; John's beliefs became ugly
GO-EXT Ident (Thing, Thing) ;; The man ranged from a villain to a hero
GO-EXT Ident (Thing, Event) ;; The article ranged from praise to attack
GO-EXT Ident (Thing, Property);; The article ranged from sublime to ridiculous
GO-EXT Ident (Event, Thing);; The party ranged from a monster to an angel (?)
GO-EXT Ident (Event, Event);; The party ranged from success to failure
GO-EXT Ident (Event, Property);; The meeting ranged from sublime to ridiculous
GO-EXT Ident (State, Thing);; His knowledge ranged from monster to an angel(?)
GO-EXT Ident (State, Event);; His knowledge ranged from praise to attack
GO-EXT Ident (State, Property);; His knowledge ranged from sublime to ridiculous
STAY IDENT (Thing, Thing) ;; The article remained a travesty
STAY IDENT (Thing, Event) ;; The article remained an attack on women
STAY IDENT (Thing, Property) ;; The article remained outrageous
STAY IDENT (Event, Thing) ;; The party remained a mess
STAY IDENT (Event, Event) ;; The party remained a revolt
STAY IDENT (Event, Property) ;; The party remained loud
STAY IDENT (State, Thing) ;; His beliefs remained an issue
STAY IDENT (State, Event) ;; His beliefs remained an attack
STAY IDENT (State, Property) ;; His beliefs remained ugly
BE IDENT (Thing, Thing) ;; The pumpkin was a coach
BE IDENT (Thing, Event) ;; The article was an attack on women
BE IDENT (Thing, Property) ;; The article was outrageous
BE IDENT (Event, Thing) ;; The party was a mess
BE IDENT (Event, Event) ;; The party was a revolt
BE IDENT (Event, Property) ;; The party was loud
BE IDENT (State, Thing) ;; His beliefs were an issue
BE IDENT (State, Event) ;; His beliefs were an attack
BE IDENT (State, Property) ;; His beliefs were ugly

Existential Field: ({Thing | Event | State}, EXIST)
GO EXIST (Thing, EXIST) ;; The boat appeared
GO EXIST (Event, EXIST) ;; A solution presented itself
GO EXIST (State, EXIST) ;; John's beliefs presented themselves
STAY EXIST (Thing, EXIST) ;; The man survived
STAY EXIST (Event, EXIST) ;; The party persisted
STAY EXIST (State, EXIST) ;; His beliefs persisted
BE EXIST (Thing, EXIST) ;; There was a man
BE EXIST (Event, EXIST) ;; There was a party
BE EXIST (State, EXIST) ;; There was an election

Circumstantial Field: (Thing, {Event | State})
GO CIRC (Thing, Event) ;; We began jogging
GO CIRC (Thing, State) ;; We began feeling sick
STAY CIRC (Thing, Event) ;; We avoided jogging
STAY CIRC (Thing, State) ;; We avoided feeling sick
BE CIRC (Thing, Event) ;; We were jogging
BE CIRC (Thing, State) ;; We were feeling sick

Perceptual Field: (Thing, {Thing | Event | State})
GO PERC (Thing, Thing) ;; Mary worried about John
GO PERC (Thing, Event) ;; Mary worried about the party
GO PERC (Thing, State) ;; Mary worried about the election
STAY PERC (Thing, Thing) ;; Mary retained John (in her memory) (?)
STAY PERC (Thing, Event) ;; Mary maintained that John ate well
STAY PERC (Thing, State) ;; Mary maintained that John was happy
BE PERC (Thing, Thing) ;; Mary wanted John
BE PERC (Thing, Event) ;; Mary wanted John to eat
BE PERC (Thing, State) ;; Mary wanted John to be happy
ACT PERC (Thing) ;; John and Mary talked
ACT_ON PERC (Thing, Thing) ;; Mary talked to John
PATH_ACT PERC (Thing, Thing);; Mary squinted at the thing
PATH_ACT PERC (Thing, Event);; Mary squinted at the commotion

Communicative Field: (Thing, {Thing | Event | State}) - usually causative
GO COMM (Thing, Thing) ;; Mary showed the book to John
GO COMM (Event, Thing) ;; Mary told the story to John
GO COMM (State, Thing) ;; Mary displayed the knowledge to John

2. Positions and Paths


Paths comprise a set of 5 closed class items: AWAY_FROM, FROM, TO, TOWARD, and VIA

Both Paths and Positions take two arguments, a logical subject (inherited from the dominating primitive) and a logical argument (called a "reference object" in Jackendoff, 1983).

Not all positions are used in every primitive-field combination: for example, only AT is used with BE CIRC.

The LCS contains two types of Positions: arguments and modifiers. The argument Positions are the reference objects of STAY and BE. Positions may also be modifiers of Events, States and Things.

All Paths are arguments, the reference objects of GO, GO-EXT, ORIENT, PATH_ACT, specifically .

3. Open class primitives.

Things (e.g. book), Properties (e.g. red), and Manners (e.g. runningly) are open class items.

Argument Type Associated with Reference Object

The following table defines the type associated with the second argument (the reference object) of each primitive. In the case of CAUSE/LET/CAUSE_EXCHANGE/ACT_ON/PATH_ACT, this type correspond to the type of the reference object itself. (ACT takes only a subject argument.) In the case of all other primitives, the type of the second argument is a prepositional relation (position or path) associated with the reference object.

PrimitiveArgument Type Associated with Ref Object


Modifiers may be selected by verbs (and as such are included in the LCS entry, i.e. the RLCS), and can be either optional or obligatory (see below). Modifiers, subject to the restrictions described below, can appear freely in the CLCS (Composed Lexical Conceptual Structures).

No Field: BOOK NIL () ;; He picked up the [book] bag

Any Field:
BE PERC (Thing, Thing) ;; He picked up the book [that John likes]
GO POSS (Thing, Thing) ;; He picked up the book [that John found]

Locational Field: ({Thing | Event | State}, {Thing | Event})
IN LOC (Event, Thing) ;; The man ate [in the cafeteria]
IN LOC (State, Thing) ;; She thought about him [in the cafeteria]
IN LOC (Thing, Thing) ;; He picked up the [book [in the box]]
IN LOC (Event, Event) ;; The man ate [in the meeting]
IN LOC (State, Event) ;; She thought about him [in the meeting]
IN LOC (Thing, Event) ;; He picked up the [book [in the meeting]]

Possessional Field: ({Thing | Event | State}, Thing)
AT POSS (Event, Thing) ;; [Bill's] party was at noon
AT POSS (State, Thing) ;; [Bill's] knowledge was extensive
AT POSS (Thing, Thing) ;; [Bill's] book was on the table

Temporal Field: ({Event | State}, {Time | Event | State})
AT TEMP (Event, Time) ;; The man ate [at noon]
AT TEMP (State, Time) ;; The man thought about it [at noon]
UNTIL TEMP (Event, Event) ;; The man ate [until the party]
UNTIL TEMP (State, Event) ;; The thought about it [until the party]
UNTIL TEMP (Event, State) ;; The man ate [until the election]
UNTIL TEMP (State, State) ;; The thought about it [until the election]

Instrumental Field: ({Event | State}, Thing)
WITH INSTR (Event, Thing) ;; John stabbed Bill [with a knife]
AS INSTR (State, Thing) ;; She imagined him [as a great pianist]
QUICKLY INSTR () ;; She ran [quickly]

Intentional: ({Event | State}, {Thing | Event | State})
FOR INTENT (Event, Thing) ;; She criticized Bill [for his messiness]
FOR INTENT (Event, Event) ;; She criticized Bill [for his party]
FOR INTENT (Event, State) ;; She criticized Bill [for his knowledge]
Note: All INTENT modifiers that are not FOR are to be deleted, although they may appear in earlier versions of the database.
ABOUT INTENT (State, Thing) ;; His knowledge [about the issue] was great
ABOUT INTENT (State, Event) ;; His knowledge [about the party] was great
ABOUT INTENT (State, State) ;; His knowledge [about the beliefs] was great
REALLY INTENT () ;; She [really] wanted to go

Identificational: (Thing, {Thing | Event | Property})
RED IDENT () ;; She liked the [red] book
REALLY IDENT () ;; She was [really] happy ;; She was [[really] happily] married
VERY IDENT () ;; She was [very] happy ;; She was [[very] happily] married

Type/Field Restrictions on Modifiers

Modifiers are restricted by type and field according to the token that is modified. If there is a logical subject of a modifier, this argument will be instantiated as *head* in the composed LCS. The following table defines the possible Types of modifiers allowed for each LCS Type. Types not allowed are prohibited, e.g. a THING can not take a time (*The book at 9:00). Note that no PATH modifiers are permitted; all PATHS are arguments.

LCS TypeType of Modifier

The following table defines the possible Fields of modifiers allowed for each LCS Type.

LCS TypeField of Modifier

WordNet Senses

WordNet senses from WN 1.5 and WN 1.6 are included in each entry, for example:

:WN_SENSE (("1.5" 01100152 01176439) ("1.6" 01317321 01406763))

Additional LCS Notation

Star markers (*)

The LCS specifies a star marker (*) for every explicitly realized argument and modifier. The star marker forces logical constituents to be realized compositionally at different levels. In particular, it serves as a pointer to a RLCS position that must be combined with another RLCS in order to arrive at a (portion of a) CLCS. The star marker can occur twice (or more) inside a node.


In the VAR_SPEC, six different markers are used: :OPTIONAL, :OBLIGATORY, :INT, :EXT, :CAT, and :CONFLATED. Although it may appear in some database versions, CND is obsolete, the counterpart to UC. The VAR_SPEC also includes features, which are described below. The :OPTIONAL/:OBLIGATORY markers are used as follows:
1. A star-marked :OPTIONAL position is a logical argument that is optional.
2. A star-marked :OBLIGATORY position is a logical modifier that is obligatory.
3. A star-marked position that has no :OPTIONAL or :OBLIGATORY marker is either an argument (which is, by default, obligatory) or a modifier (which is, by default, optional).

The :INT/:EXT markers force the composition algorithm to be overridden with respect to the positioning of the logical subject and logical argument (see below). For example, in Class 9.8.b, the logical modifier (position 16) is swapped with the logical subject (position 2), thus accommodating the sentence "The tinsel decorated the tree". This is achieved by means of the following specification: (16 :ext) (2 :int).

The :CAT marker is used to indicate a non-default category. For example, the :CAT marker in (8 (:cat n)) in 41.1.1.h indicates that this event position corresponds to a noun phrase; if the :CAT marker were not present, the event would be realized in its canonical form (a verb phrase). For canonical realization, see Dorr 1993, references to canonical syntactic realizations, or CSR).

Elements of the LCS that are included in the meaning of the constant are specified by the :CONFLATED marker., e.g. the manner component in the LCS entry example above. Some conflated elements are also star marked. In such cases, if the :TYPE keyword is NOT specified, then the primitive must match exactly. Else, only the type must match.


The notation ((0 "up")) (as in 9.8.e) indicates that the particle "up" is associated with the head, not any argument. That is, in the sentence "I looked for the book", a particle specification for "for" will yield a VP with the constituents: a V (look_for) and an NP (the_book). As a collocation (see D. below) the parser will yield a V (look) and a PP (for_the_book).


The notation ((16 "of")) used in the :COLLOCATION slot (as in 10.6.b) indicates that the `out of' particle is associated with the item that will fill position 16.

Relation of LCS to Thematic Roles

The LCS variables are represented by numbers that map directly into thematic roles. The application of a particular role to a class of verbs was based, to the extent possible, on properties outlined in Jackendoff (1983, 1990).

Just as LCS contains two types of positions (arguments and modifiers), thematic roles are correspondingly divided into two types (described below).

Code enforcing these values uses the file lcs-code/theta-codes.lisp. If there are descrepencies, that file takes precendence.


1 = AG, agent Logical subject of CAUSE, LET. If restricted to [-animate], an instrumental subject, as in The hammer broke the vase.

2 = EXP, experiencer Logical subject of GO PERC, BE PERC, ACT_ON PERC, ACT PERC, PATH_ACT PERC.

2 = INFO, information Logical subject of GO COMM, BE COMM

2 = TH, theme Logical subject of everything not mentioned under AG and PERC (8 below). In previous versions of the database, every LCS had either a TH or an EXP. Subsequent addition of the ACT primitive introduced the possibility of AG-only LCSs.

3 = SRC(), source preposition Indicates Path FROM or Path AWAY_FROM. Marks path prepositions or particles indicating source, e.g. from, away from, etc. (ex. John ran *away* from home).

4 = SRC, source Logical argument Paths FROM and Path AWAY_FROM. The SRC role indicates where the TH started its motion (in LOC), what its original state (IDENT) was, or where its original (possibly abstract) location was (in POSS) (ex. John left *the house*).

5 = GOAL(), goal preposition Indicates Position AT (in a Path-like sense) or Paths TO/TOWARD (in any field except Ident). This slot marks path prepositions or particles indicating goals, e.g. to, toward (ex. John ran *to* the store).

5 = PRED(), pred preposition Indicates Paths TO/TOWARD Ident. This slot marks path prepositions or particles indicating goals in the identificational field, e.g. to, toward (ex. John turned into a monkey).

6 = GOAL, goal Logical argument of Path TO (in any field except Ident) or TOWARD (in the LOC field only). The GOAL role indicates the endpoint of motion (in LOC) or the final (possibly abstract)location (ex. John ran *home*)

7 = PERC(), perceived item particle Indicates Paths TO/TOWARD PERC (ex. He looked *into the room*).

8 = PERC, perceived item Logical subject of GO PERC, BE PERC, ACT_ON PERC, ACT PERC, PATH_ACT PERC. The PERC role indicates entities that may be perceived (ex. He saw *the play*).

9 = PRED, identificational predicate Logical argument of GO IDENT, BE IDENT, ACT_ON IDENT, ACT IDENT, PATH_ACT IDENT. A thing/property (in IDENT) or a new state of existence (in EXIST) (ex. We considered him *a fool*)

10 = LOC(), locational particle Indicates Positions AT/IN/ON LOC. This slot marks prepositions preceding static locations, (ex. He lived *in* France).

11 = LOC, locational predicate Logical argument of BE LOC, STAY LOC. A static location, not a source or a goal in the LOC field (ex. The water fills *the box*)

12 = POSS, possessional predicate Logical argument of BE POSS, Logical subject of GO POSS. POSS is the possessed entity. (ex. This box carries *five eggs*).

13 = TIME(), temporal particle preceding time Indicates Positions AT/IN/ON TEMP or Paths TO/TOWARD/FROM/AWAY_FROM TEMP. This slot marks prepositions preceding time. Not currently used in the verbs, although maybe in composed structures (ex., John ate *at* nine).

14 = TIME, time for TEMP field Logical argument of BE TEMP, GO TEMP. Temporal argument, not currently used in verb lexicon, but in constant of verb lexicon (ex. John *summered* at the cabin) and in prep lexicon.

27 = PROP, event or state Logical argument of BE CIRC, GO CIRC, STAY CIRC. Non perceptual proposition.


15 = MOD-POSS(), possessional particle corresponding to Positions WITH/IN/OF/FROM POSS and FOR INSTR. Precedes a possessional modifier or monetary unit of exchange, e.g., He loaded the cart *with* hay, He bought it *for* $5.

16 = MOD-POSS, possessed item modifier, e.g., money, rights. Logical argument of possessive modifier inside WITH/IN/OF/FROM POSS.

17 = BEN(), intentional particle corresponding to Position FOR POSS. Precedes benefactive modifier, e.g., John baked the cake *for* Mary.

18 = BEN, benefactive modifier, e.g., John baked *Mary* a cake. Logical argument of benefactive modifier inside for poss. (associated with collocation "to".)

19 = INSTR(), instrumental particle corresponding to Positions with/by/of/on instr. Precedes instrument modifier, e.g., John broke the glass *with* a stick.

20 = INSTR, instrument modifier and subject of cause, e.g., *The stick* broke the glass; John broke the glass with *a stick* logical argument of instrumental modifier inside with/by/of/on instr.

21 = PURP(), intentional particle corresponding to position for intent. Precedes purpose clause, e.g., He studied *for* the exam, He searched *for* rabbits. (Indicates "because of" or searched item.)

22 = PURP, purpose modifier or reason, e.g., He studied for *the exam*). We currently don't have any uses without particles in our verb lexicon.

23 = MOD-LOC(), location particle corresponding to a Positions AROUND/FROM/DOWN/etc LOC. Precedes locational modifier, e.g., She held the child *in* her arms.

24 = MOD-LOC, location modifier Logical argument of locational modifier inside AROUND/FROM/DOWN/etc LOC. A location that isn't required by the verb but modifies the entire situation. Especially for composed structures.

25 = MANNER() (not -ingly)

26 = reserved for conflated manner component (-ingly)

28 = MOD-PROP, event or state. Non-perceptual proposition not required by the verb.

29 = MOD-PRED(), identificational particle corresponding to Position AS IDENT. Precedes property modifier, e.g., She imagined him *as* a prince.

30 = MOD-PRED, property modifier.

31 = MOD-TIME, time modifier.

32 = MOD-PERC(), perceptual modifier particle.

33 = MOD-PERC, perceptual modifier.

34 = PARTICLE, other particle, more often handled via collocation.


The format for thematic roles is the following: 1. Any theta role preceded by an underscore (_) is obligatory. 2. Any theta role preceded by an underscore (,) is optional. 3. Prepositions inside parentheses indicate that the corresponding phrases must necessarily be headed by the specified prepositions. 4. An empty set of parentheses () indicates that there NECESSARILY must be a prepositional head, but it is left unspecified. If there are no parentheses, then there is no prepositional head.

Example: ag_th,src(from),goal(to)

Here, ag and th are obligatory; the rest are optional.

Although theta roles are theoretically unordered, they are generally specified in a "canonical" ordering that is thought to arise most frequently. In general, surface order reflects the numeric order of thematic roles (e.g. 1 = AG before 2=TH). If numeric order is NOT reflected in the surface order, an :int and :ext operator is encoded in the LCS (as discussed above) indicating that the logical subject is the semantic object, and the logical object is the semantic subject. This parameter can also apply to PP roles. Thus, the _th_loc grid is NOT the same as the _loc_th grid, as seen in the examples below:

THETA_ROLES: "_loc_th"
SENTENCE: "The box holds the ball"

THETA_ROLES: "_th_loc"
SENTENCE: "The water fills the box"

Relation of LCS to PropBank

In October of 2001 we mapped our 250+ thematic grids to the PropBank argument frames (using VerbNet)---a mapping done by hand in 2.5 hours. A new slot called :PROPBANK was added to the LCS database to accommodate this mapping.

The mapping is given below. It seems that, modulo this mapping, the PropBank and LCS resources are very similar, with some differences in breadth (the LCS database broader) and depth (the PropBank is more in-depth). Relevant comments on this are given below.

Some comments about the mapping:

LCS DatabasePropBank
,ag_th arg0 arg1
,ag_th,goal()arg0 arg1 arg2(to - up.)
,ag_th,goal(),instr(with)arg0 arg1 arg2(with)
,ag_th,goal(into)arg0 arg1 arg2(into)
,ag_th,goal(to)arg0 arg1 arg2(to)
,ag_th,goal(to),src()arg0 arg1 arg2(to) arg2(from - up.)
,ag_th,goal(with)arg0 arg1 arg2(with)
,ag_th,instr(with)arg0 arg1 arg2(with)
,ag_th,loc()arg0 arg1 argm-LOC(in/on - up.)
,ag_th,mod-loc(apart)arg0 arg1 argm-LOC(apart)
,ag_th,mod-loc(together)arg0 arg1 argm-LOC(together)
,ag_th,mod-loc(together),instr(with)arg0 arg1 argm-LOC(together) arg2(with)
,ag_th,mod-poss(of)arg0 arg1 arg3(of)
,ag_th,src(),goal()arg0 arg1 arg2(to - up.) arg2(from - up.)
,ag_th,src(from)arg0 arg1 arg2(from)
,ag_th,src(from),goal()arg0 arg1 arg2(from) arg2(to - up.)
,ag_th_goal() arg0 arg1 arg2(to - up.)
,ag_th_goal(around)arg0 arg1 arg2(around)
,ag_th_goal(into)arg0 arg1 arg2(into)
,ag_th_goal(into),ben(for)arg0 arg1 arg3(for)
,ag_th_goal(to)arg0 arg1 arg2(to)
,ag_th_goal(with)arg0 arg1 arg2(with)
,ag_th_loc()arg0 arg1 argm-LOC(in/on - up.)
,ag_th_loc(in)arg0 arg1 argm-LOC(in)
,ag_th_src(from)arg0 arg1 arg2(from)
,ag_th_src(off-of,off)arg0 arg1 arg2(off-of/off)
00 (no args - eg., weather verbs)
_ag,ben(for)arg0 arg3(for)
_ag,goal(at)arg0 arg2(at)
_ag,goal(to),info(about)arg0 arg2(to) arg1(about)
_ag,goal(to)_info(that)arg0 arg2(to) arg1-PRD(that)
_ag,goal(to)_info(that,about)arg0 arg2(to) arg1-PRD(that/about)
_ag,goal,th,purp(for)arg0 arg2 arg1 arg3(for)
_ag,goal_info(of,about)arg0 arg2 arg1(of/about)
_ag,goal_info(that,to)arg0 arg2 arg1-PRD(that/to)
_ag,info,src(from)arg0 arg1 arg2(from)
_ag,info_goal(to)arg0 arg1 arg2(to)
_ag,instr,goal(at)arg0 arg1 arg2(at)
_ag,locarg0 arg1
_ag,mod-loc()arg0 argm-LOC(in/on - up.)
_ag,mod-loc()_th(after)arg0 arg1(after) argm-LOC(down - up.)
_ag,mod-loc(together)arg0 argm-LOC(together)
_ag,mod-poss(with),info(about)arg0 arg2(with) arg1(about)
_ag,prop(that),goal(to)arg0 arg1-PRD(that) arg2(to)
_ag,purp(for),loc()arg0 arg3(for) argm-LOC(in/on -up.)
_ag,src,th,purp(for)arg0 arg2 arg1 arg3(for)
_ag,tharg0 arg1
_ag_ben_tharg0 arg2 arg1
_ag_ben_th,instr()arg0 arg2 arg1 arg3(with - up.)
_ag_ben_th,mod-poss(for)arg0 arg2 arg1 arg3(for)
_ag_ben_th,src()arg0 arg2 arg1 arg2(from - up.)
_ag_ben_th,src(from),mod-poss(for)arg0 arg2 arg1 arg2(from) arg3(for)
_ag_exp(to)_perc(about)arg0 arg2(to) arg1(about)
_ag_exp,instr(with)arg0 arg1 arg2(with)
_ag_goalarg0 arg1
_ag_goal(at)arg0 arg1(at)
_ag_goal(at),instr(with)arg0 arg1(at) arg2(with)
_ag_goal(at,on)arg0 arg1(at/on)
_ag_goal(at,toward)arg0 arg1(at/toward)
_ag_goal(to),info(about)arg0 arg2(to) arg1(about)
_ag_goal(to)_info(about,that)arg0 arg2(to) arg1(about/that)
_ag_goal,infoarg0 arg2 arg1
_ag_goal,info(that,to)arg0 arg2 arg1(that/to)
_ag_goal,purp(for),mod-pred(as)arg0 arg1 arg3(for) arg3(as)
_ag_goal,tharg0 arg2 arg1
_ag_goal_infoarg0 arg2 arg1
_ag_goal_info(about)arg0 arg2 arg1(about)
_ag_goal_info(about,that)arg0 arg2 arg1-PRD(about/that)
_ag_goal_info(against)arg0 arg2 arg1-PRD(against)
_ag_goal_info(that)arg0 arg2 arg1-PRD(that)
_ag_goal_info(to)arg0 arg2 arg1-PRD(to)
_ag_goal_purp(for),mod-pred(as)arg0 arg1 arg3(for) arg3(as)
_ag_goal_tharg0 arg2 arg1
_ag_goal_th,ben(for),instr(for)arg0 arg2 arg1 arg3(for) arg4(for)
_ag_goal_th,src()arg0 arg2 arg1 arg2(from - up.)
_ag_goal_th,src(from)arg0 arg2 arg1 arg2(from)
_ag_info(about),goal(to)arg0 arg1(about) arg2(to)
_ag_info(of,about),src(from)arg0 arg1(of/about) arg2(from)
_ag_info(that)arg0 arg1(that)
_ag_info,goal(to)arg0 arg1 arg2(to)
_ag_info_goal(to)arg0 arg1 arg2(to)
_ag_locarg0 arg1(in/on - up)
_ag_loc(),purp(for)arg0 arg1(in/on - up.) arg3(for)
_ag_loc()_purp(for)arg0 arg1(in/on - up.) arg3(for)
_ag_loc(on)arg0 arg1(on)
_ag_loc,purp(for)arg0 arg1 arg3(for)
_ag_loc_purp(for)arg0 arg1 arg3(for)
_ag_mod-locarg0 argm-LOC(in/on - up.)
_ag_mod-possarg0 arg3
_ag_mod-poss(from)arg0 arg3(from)
_ag_mod-poss(in)arg0 arg3(in)
_ag_mod-poss(on)arg0 arg3(on)
_ag_mod-poss(with)arg0 arg2(with)
_ag_mod-pred(as)arg0 arg3(as)
_ag_particle(up)arg0 [particle ignored]
_ag_proparg0 arg1
_ag_prop(to)arg0 arg1-PRD(to)
_ag_purp(for)arg0 arg3(for)
_ag_purp(for),loc()arg0 arg3(for) argm-LOC(in/on - up.)
_ag_purp,loc()arg0 arg3 argm-LOC(in/on - up.)
_ag_srcarg0 arg2
_ag_tharg0 arg1
_ag_th(against)arg0 arg1(against)
_ag_th,ben(for)arg0 arg1 arg2(for)
_ag_th,goal()arg0 arg1 arg2(to - up.)
_ag_th,goal(at)arg0 arg1 arg2(at)
_ag_th,goal(on)arg0 arg1 arg2(on)
_ag_th,goal(to)arg0 arg1 arg2(to)
_ag_th,goal(to),ben(for),instr(for)arg0 arg1 arg2(to) arg3(for) arg4(for)
_ag_th,goal(to),src(from)arg0 arg1 arg2(to) arg2(from)
_ag_th,instr(),ben(for)arg0 arg1 arg3(with - up.) arg3(for)
_ag_th,instr(by)arg0 arg1 argm-LOC(by)
_ag_th,instr(with)arg0 arg1 arg3(with)
_ag_th,instr(with),mod-loc()arg0 arg1 arg3(with) argm-LOC(in/on - up.)
_ag_th,loc()arg0 arg1 argm-LOC(in/on - up.)
_ag_th,mod-loc()arg0 arg1 argm-LOC(in/on - up.)
_ag_th,mod-loc(),instr(with)arg0 arg1 argm-LOC(in/on - up.) arg3(with)
_ag_th,mod-loc(down)arg0 arg1 argm-LOC(down)
_ag_th,mod-loc(down),src(),goal()arg0 arg1 argm-LOC(down) arg2(from - up.) arg2(to - up.)
_ag_th,mod-loc(from),mod-loc()arg0 arg1 arg2(from) argm-LOC(in/on - up.)
_ag_th,mod-loc(together)arg0 arg1 argm-LOC(together)
_ag_th,mod-loc(up),src(),goal()arg0 arg1 argm-LOC(up) arg2(from - up.) arg2(to - up.)
_ag_th,mod-poss(for),ben(for)arg0 arg1 arg4(for) arg3(for)
_ag_th,mod-poss(in)arg0 arg1 arg3(in)
_ag_th,mod-poss(of)arg0 arg1 arg3(of)
_ag_th,mod-poss(out_of)arg0 arg1 arg3(out_of)
_ag_th,mod-poss(with)arg0 arg1 arg3(with)
_ag_th,mod-poss(with)_particle(up)arg0 arg1 arg3(with) [particle ignored]
_ag_th,mod-pred(as)arg0 arg1 arg3(as)
_ag_th,predarg0 arg1 arg3
_ag_th,prop(to)arg0 arg2 arg1-PRD(to)
_ag_th,src()arg0 arg1 arg2(from - up.)
_ag_th,src(),ben(for)arg0 arg1 arg2(from - up.) arg3(for)
_ag_th,src(),goal()arg0 arg1 arg2(from - up.) arg2(to - up.)
_ag_th,src(from)arg0 arg1 arg2(from)
_ag_th,src(from),ben(for)arg0 arg1 arg2(from) arg3(for)
_ag_th,src(from),ben(for),mod-poss(for)arg0 arg1 arg2(from) arg3(for) arg4(for)
_ag_th,src(from),goal(to)arg0 arg1 arg2(from) arg2(to)
_ag_th_goal()arg0 arg1 arg2(to - up.)
_ag_th_goal(),instr(with)arg0 arg1 arg2(to - up.) arg3(with)
_ag_th_goal(among)arg0 arg1 arg2(among)
_ag_th_goal(at)arg0 arg1 arg2(at)
_ag_th_goal(into)arg0 arg1 arg2(into)
_ag_th_goal(into),ben(for)arg0 arg1 arg2(into) arg3(for)
_ag_th_goal(on,for)arg0 arg1 arg3(on/for)
_ag_th_goal(through)arg0 arg1 arg2(throught)
_ag_th_goal(to)arg0 arg1 arg2(to)
_ag_th_loc()arg0 arg1 argm-LOC(in/on - up.)
_ag_th_loc(at)arg0 arg1 arg2(at)
_ag_th_mod-loc(against)arg0 arg1 argm-LOC(against)
_ag_th_mod-loc(along)arg0 arg1 argm-LOC(along)
_ag_th_mod-poss(of)arg0 arg1 arg3(of)
_ag_th_particle(down)arg0 arg1 [particle ignored]
_ag_th_particle(up)arg0 arg1 [particle ignored]
_ag_th_predarg0 arg1 arg3
_ag_th_pred(from)arg0 arg1 arg3(from)
_ag_th_proparg0 arg2 arg1
_ag_th_prop(to)arg0 arg2 arg1-PRD(to)
_ag_th_src()arg0 arg1 arg2(from - up.)
_ag_th_src(),instr(with)arg0 arg1 arg2(from - up.) arg3(with)
_ag_th_src(from)arg0 arg1 arg2(from)
_ag_th_src(out_of)arg0 arg1 arg2(out_of)
_exp,goal,src(from)arg0 arg1-REC arg2(from)
_exp,mod-poss(with),mod-perc(about)arg1-REC arg2(with) arg1(about)
_exp,purp(for)arg1 arg3(for)
_exp,src(at,from)arg1 arg3(at/from)
_exp,src(from)arg1 arg3(from)
_exp_ag(at)arg1 arg3(at)
_exp_goal(at)arg1 arg3(at)
_exp_mod-poss(with)arg1 arg3(with)
_exp_percarg0 arg1
_exp_perc(about)arg0 arg1(about)
_exp_perc(against)arg0 arg1(about)
_exp_perc(around,through,into)arg0 arg1(around/through/into)
_exp_perc(at)arg0 arg1(at)
_exp_perc(at,from)arg0 arg1(at/from)
_exp_perc(for,after)arg0 arg1(for/after)
_exp_perc(from)arg0 arg1(from)
_exp_perc(in)arg0 arg1(in)
_exp_perc(of,about)arg0 arg1(of/about)
_exp_perc(on)arg0 arg1(on)
_exp_perc(on),purp(for),mod-pred(as)arg0 arg1(on) arg3(for) arg3(as)
_exp_perc(over)arg0 arg1(over)
_exp_perc(that)arg0 arg1(that)
_exp_perc(to)arg0 arg1-PRD(to)
_exp_perc,mod-loc(from)arg0 arg1 argm-LOC(from)
_exp_perc,mod-poss(in)arg0 arg1 arg3(in)
_exp_perc,mod-predarg0 arg1 arg3
_exp_perc,mod-pred(as)arg0 arg1 arg3(as)
_exp_perc,mod-prop(to)arg0 arg2 arg1-PRD(to)
_exp_perc,purp(for)arg0 arg2 arg3(for)
_exp_perc,purp(for),mod-pred(as)arg0 arg1 arg3(for) arg3(as)
_exp_perc_mod-predarg0 arg1 arg3
_exp_perc_mod-prop(to)arg0 arg2 arg1-PRD(to)
_exp_prop(that)arg0 arg1-PRD(that)
_goal_tharg0 arg1
_loc_tharg0 arg1
_loc_th(with)arg1 arg3(with)
_mod-poss_tharg0 arg1
_perc_exp(on)arg1 arg3(on)
_perc_goal(to)arg1 arg3(to)
_poss_tharg0 arg1
_prop(that)_exparg0(that) arg1
_src_tharg0 arg1
_th,ben(for)arg1 arg3(for)
_th,ben(to)arg1 arg3(to)
_th,goalarg1 arg2
_th,loc()arg1 argm-LOC(over - up.)
_th,loc(up)arg1 argm-LOC(up)
_th,mod-loc()arg1 argm-LOC(on - up.)
_th,mod-loc(along)arg1 argm-LOC(along)
_th,mod-loc(around)arg1 argm-LOC(around)
_th,mod-loc(before)arg1 argm-LOC(before)
_th,mod-loc(down)arg1 argm-LOC(down)
_th,mod-loc(on)arg1 argm-LOC(on)
_th,mod-loc(together)arg1 argm-LOC(together)
_th,mod-poss(of)arg1 arg3(of)
_th,proparg1 arg2
_th,srcarg1 arg2
_th,src(),goal()arg1 arg2(from - up.) arg2(to - up.)
_th,src(from),goal(to)arg1 arg2(from) arg2(to)
_th,src(from),mod-loc()arg1 arg2(from) argm-LOC(on - up.)
_th_goalarg0 arg1
_th_goal()arg1 argm-LOC(through - up.)
_th_goal(on,onto)arg1 argm-LOC(on/onto)
_th_goal(through)arg1 argm-LOC(through)
_th_goal(to)arg1 argm-LOC(to)
_th_goal(with)arg1 arg3(with)
_th_goal(with,to)arg1 arg3(with/to)
_th_instr(on)arg1 argm-LOC(on)
_th_locarg0 arg1
_th_loc()arg1 argm-LOC(on - up.)
_th_loc(through,in)arg1 argm-LOC(through/in)
_th_mod-loc(together)arg1 argm-LOC(together)
_th_mod-poss(of)arg1 arg3(of)
_th_mod-poss(with)arg1 arg3(with)
_th_mod-poss_goal()arg0 arg1 argm-LOC(down - up.)
_th_particle(down),src(),goal()arg1 arg2(from - up.) arg2(to - up.) [particle ignored]
_th_perc(of,about)arg0 arg1(of/about)
_th_possarg1 arg1-PRD
_th_predarg1 arg3
_th_pred,mod-perc(to)arg1 arg1-PRD arg0(to)
_th_pred,mod-poss(with)arg0 arg1-PRD arg1(with)
_th_proparg1 arg2
_th_prop(to)arg0 arg1-PRD(to)
_th_purp(for)arg1 arg3(for)
_th_src(from)arg1 arg2(from)
_th_src(from)_goal(to)arg1 arg2(from) arg2(to)
_th_src(through)arg1 argm-LOC(through)
_th_time()arg1 argm-TMP


Semantic Features are a combination of Longman's features plus additional ones (like num) used in the LCS lexicon entries. The first element given is the feature, the remaining the possible values.

(money + -)
(thing + -)
(event + -)
(state + -)
(num plur sing)
(animate + -)
(human + -)
(animal + -)
(plant + -)
(solid + -)
(movable + -)
(abstract + -)
(def indef def)
(quantifier exists not-exists many every wh-quantifier not several another every 1 2 3 ....)
(count + -)

The following syntactic features are used by the syntactic parser, but get passed down into the composed LCS representation. All of these are used in the Arabic parser. For other languages the values of the features may change, and possibly the names as well. Not all features may be used for all languages.

(adj + -)
(quantifier + -)
(expletive + -)
(imperative + -)
(human + -)
(be + -)
(case nom acc gen )
(num sing dual plur)
(gen m f )
(person first second third)
(def def indef)
(aspect perfect imperf imperative)
(comp yn wh rel subord other)
(mood indic subj juss )
(voice active passive)
(theta ag th exp ben goal src instr pred event cause time loc poss)
(has_subject + -)
(sc + -)
(adverb goal src)
(feature adj adv)
(art def indef)

These are additional syntactic features that are used in the parser:

(adv + -)
(adv_s + -)
(adv_v + -)
(aux + -)
(att + -)
(bare_inf + -)
(barrier + -)
(ca + -)
(cap + -)
(cm + -)
(cmp + -)
(country + -)
(ct + -)
(det + -)
(easy + -)
(event + -)
(fname + -)
(free_rel + -)
(gap + -)
(genitive + -)
(gname + -)
(govern + -)
(have + -)
(head_final + -)
(hyp + -)
(infl + -)
(inv + -)
(last_conj + -)
(loc + -)
(neg + -)
(opt + -)
(passive + -)
(perf + -)
(pg + -)
(pged + -)
(plu + -)
(pn + -)
(ppro + -)
(prd + -)
(pro + -)
(prog + -)
(pron + -)
(province + -)
(ref + -)
(refl + -)
(reg + -)
(restrictive + -)
(superlative + -)
(title + -)
(topic + -)
(trace + -)
(wh + -)
(whvacuous + -)
(aform norm er est)
(auxform to can could do did does may might would should must will ought shall have_to be_going_to)
(cat c i n v a p d j )
(mvtype wh np)
(vform bare s ed ing)
(rare very very_very)
(pred n v a p)
(nform there it norm ing)
(cform fin inf npsc apsc ppsc vpsc)
(tense inf present past future pastfut)