To download the LCS Database, click here. Please read the copyright notice and documentation below. References to relevant papers are also included.
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: bonnie@umiacs.umd.edu.
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.
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)
(down+/m))
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)
(down+/m))
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+)
(textile+)
(export+))
(to ident (quota+ (china+)
(textile+)
(export+))
(at ident (quota+ (china+)
(textile+)
(export+))
(reduce+ed))))
(with instr (*HEAD*) nil)
(unilaterally+/m))
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):
*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})
Locational Field: ({Thing | Event | State}, {Thing | Event})
(Motion/location in space. See Jackendoff)
ACT LOC (Thing) ;; John exercised
Possessional Field: ({Thing | Event | State}, Thing)
Temporal Field: ({Event | State}, {Time | Event | State})
Identificational Field: ({Thing | Event | State}, {Thing | Event | Property})
Existential Field: ({Thing | Event | State}, EXIST)
Circumstantial Field: (Thing, {Event | State})
Perceptual Field: (Thing, {Thing | Event | State})
Communicative Field: (Thing, {Thing | Event | State}) - usually causative
2. Positions and Paths
Positions comprise a set of approximately 65 closed class items:
ABOARD, ABOUT, ABOVE, ACROSS, AFTER, AGAINST, ALONG, ALSO, AMONG,
APART, AROUND, AS, AT, BACK, BECAUSE, BEFORE, BEHIND, BETWEEN, BEYOND,
BY, CO, CONSIDERING, DESPITE, DOWN, DURING, EAST, EXCEPT, FOR, FRONT,
IN, INSIDE, INSTEAD, LEFT, NEAR, NEXT, NORTH, NOT, NOT, NOT, NOT, OF,
OFF, ON, OUT, OUTSIDE, OVER, PAST, PENDING, PER, REGARDING,
REGARDLESS, RELATIVE, RIGHT, SIDE, SINCE, SOUTH, SUPPORT, THAN, UNDER,
UNTIL, UP, WEST, WITH, and WITHOUT.
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.
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.
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:
Locational Field: ({Thing | Event | State}, {Thing | Event})
Possessional Field: ({Thing | Event | State}, Thing)
Temporal Field: ({Event | State}, {Time | Event | State})
Instrumental Field: ({Event | State}, Thing)
Intentional: ({Event | State}, {Thing | Event | State})
Identificational: (Thing, {Thing | Event | Property})
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.
The following table defines the possible Fields of modifiers allowed
for each LCS Type.
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))
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:
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 ((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.
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"
THETA_ROLES: "_th_loc"
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:
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 + -)
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 + -)
These are additional syntactic features that are used in the parser:
(adv + -)
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)
Primitives
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
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_ON LOC (Thing, Thing) ;; John swept the floor
PATH_ACT LOC (Thing, Event) ;; John turned his back at the commotion
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
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
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
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
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
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
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
Argument Type Associated with Reference Object
Primitive Argument Type Associated with Ref Object
LET, CAUSE EVENT or STATE
GO, GO-EXT, ORIENT, PATH_ACT PATH
STAY, BE POSITION
ACT_ON THING
PATH_ACT THING
Modifiers
BE PERC (Thing, Thing) ;; He picked up the book [that John likes]
GO POSS (Thing, Thing) ;; He picked up the book [that John found]
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]]
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
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]
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]
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
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
LCS Type Type of Modifier
EVENT POSITION, MANNER, TIME, INTENSIFIER
STATE POSITION, MANNER, TIME, INTENSIFIER
THING POSITION, THING, PROPERTY, EVENT, STATE
PROPERTY INTENSIFIER
MANNER INTENSIFIER
LCS Type Field of Modifier
EVENT POSS, LOC, TEMP, INTENT, INSTR
STATE POSS, LOC, TEMP, INTENT, INSTR
THING LOC, POSS, IDENT
PROPERTY IDENT
MANNER IDENT
WordNet Senses
Additional LCS Notation
Star markers (*)
VAR_SPEC
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).
Particles
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).
Collocations
Relation of LCS to Thematic Roles
LOGICAL ARGUMENTS: AG,EXP,TH,SRC,GOAL,INFO,PERC,PRED,LOC,POSS,TIME,PROP
LOGICAL MODIFIERS: MOD-POSS, BEN, INSTR, PURP, MOD-LOC, MANNER, MOD-PROP
THEMATIC ROLE SPECIFICATION
SENTENCE: "The box holds the ball"
SENTENCE: "The water fills the box"
Relation of LCS to PropBank
LCS Database PropBank
,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)
0 0 (no args - eg., weather verbs)
_ag arg0
_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,loc arg0 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,th arg0 arg1
_ag_ben_th arg0 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_goal arg0 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,info arg0 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,th arg0 arg2 arg1
_ag_goal_info arg0 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_th arg0 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_loc arg0 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-loc arg0 argm-LOC(in/on - up.)
_ag_mod-poss arg0 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_prop arg0 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_src arg0 arg2
_ag_th arg0 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,pred arg0 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_pred arg0 arg1 arg3
_ag_th_pred(from) arg0 arg1 arg3(from)
_ag_th_prop arg0 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 arg1
_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_perc arg0 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-pred arg0 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-pred arg0 arg1 arg3
_exp_perc_mod-prop(to) arg0 arg2 arg1-PRD(to)
_exp_prop(that) arg0 arg1-PRD(that)
_goal arg1
_goal_th arg0 arg1
_loc_th arg0 arg1
_loc_th(with) arg1 arg3(with)
_mod-poss(with) arg3(with)
_mod-poss_th arg0 arg1
_perc_exp(on) arg1 arg3(on)
_perc_goal(to) arg1 arg3(to)
_poss_th arg0 arg1
_prop(that)_exp arg0(that) arg1
_src arg1
_src_th arg0 arg1
_th arg1
_th,ben(for) arg1 arg3(for)
_th,ben(to) arg1 arg3(to)
_th,goal arg1 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,prop arg1 arg2
_th,src arg1 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_goal arg0 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_loc arg0 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_poss arg1 arg1-PRD
_th_pred arg1 arg3
_th_pred,mod-perc(to) arg1 arg1-PRD arg0(to)
_th_pred,mod-poss(with) arg0 arg1-PRD arg1(with)
_th_prop arg1 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
FEATURES
(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 + -)
(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)
(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)