Resolvable semantic type and resolvable semantic type resolution

[0001] This application is a continuation of U.S. patent application Ser. No. 10/830,988, filed Apr. 23, 2004, entitled “SEMANTIC PROGRAMMING LANGUAGE”.

[0002] The present invention relates to a system and method for modeling the semantics of a natural language. More particularly, the present invention relates to resolvable types and resolvable type resolution within a semantic programming language for processing natural language input.

[0003] A natural language is language as produced by people (as opposed to computer languages or other artificial languages), including all of the idioms, assumptions and implications of the utterance or text. In the context of natural language processing, a command and control system processes natural language utterances or texts and attempts to recognize and to interpret the utterance or text to derive a usable interpretation.

[0004] Conventionally, one technique for providing natural language command and control involves static recognition of pre-encoded commands. For example, commercially available voice-to-text programs allow the user to use simple commands to initiate pre-encoded operations, such save file. However, such programs typically cannot process such commands unless the exact command is used. In other words, store file may not be properly understood by an application coded to recognize the command save file.

[0005] Similarly, question/answer type applications typically include pre-encoded phrases or terms in order to facilitate search and retrieve-type functions. However, conventional implementations require the specific search term to be used in the utterance or text in order to succeed, and consequently cannot adequately account for the richness of human speech.

[0006] Programming natural language applications is extremely difficult. Typically, programmers know how to code in a computer language, but have little experience diagramming sentence structures and/or performing linguistic analysis. This deficiency makes programming for natural language applications difficult. Moreover, extending a natural language software application coded for the English language to work with other languages typically requires recoding, not only of the software application, but also of any associated linguistic analysis engines. This makes programming for natural language applications extremely difficult and potentially very expensive.

[0007] A system for developing natural language enabled software applications is described. Resolvable types define abstract representations of linguistic elements and interrelationships between linguistic elements of a natural language input. Resolution semantics define procedural rules for resolving validity of instances of the resolvable types in a natural language enabled software application.

[0008] A method for determining validity of an instantiation of a resolvable type in a natural language enabled software program is described. A proposed interpretation list proposed interpretations of a natural language input is assembled. Each proposed interpretation has one or more commands and optionally non-command elements mapped to resolvable types. Validity of an instantiation associated with each proposed interpretation is determined in the natural language enabled software application.

[0019] A. Overview

[0020] The present invention is a Linguistic Object Model (LOM), a semantic framework, and a semantic programming language (SPL) for producing natural language applications. The LOM models semantic utterances independent of the natural language used or the application domain involved. The semantic framework includes a runtime component (an Interpreter), which mediates between natural language analysis engine(s) and a client application, and a set of types, which define the nature of the interaction between all components of the system. The SPL provides a programming framework for interfacing with the LOM and with natural language analysis engines adapted to operate with the LOM. The SPL may also be used to interface with other linguistic object models.

[0021] The present invention includes the overall process and architecture in addition to a number of the subprocesses and data structures. In order to better understand the present invention, one exemplary environment, which can be used with the present invention, is introduced. However, it should be appreciated that the present invention can be used in a wide variety of other systems and environments as well.

[0022] B. Illustrative Operating Environment

[0023] FIG. 1 illustrates an example of a suitable computing system environment 100 on which the invention may be implemented. The computing system environment 100 is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the computing environment 100 be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in the exemplary operating environment 100.

[0024] The invention is operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well-known computing systems, environments, and/or configurations that may be suitable for use with the invention include, but are not limited to, personal computers, server computers, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, telephony systems, distributed computing environments that include any of the above systems or devices, and the like.

[0025] The invention may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, and the like. that perform particular tasks or implement particular abstract data types. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

[0026] With reference to FIG. 1, an exemplary system for implementing the invention includes a general-purpose computing device in the form of a computer 110. Components of computer 110 may include, but are not limited to, a processing unit 120, a system memory 130, and a system bus 121 that couples various system components including the system memory to the processing unit 120. The system bus 121 may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus.

[0027] Computer 110 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 110 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. The phrase “computer storage media” is intended to include both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computer 110. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.

[0028] The system memory 130 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 131 and random access memory (RAM) 132. A basic input/output system 133 (BIOS), containing the basic routines that help to transfer information between elements within computer 110, such as during start-up, is typically stored in ROM 131. RAM 132 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 120. By way of example, and not limitation, FIG. 1 illustrates operating system 134, application programs 135, other program modules 136, and program data 137.

[0029] The computer 110 may also include other removable/non-removable volatile/nonvolatile computer storage media. By way of example only, FIG. 1 illustrates a hard disk drive 141 that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive 151 that reads from or writes to a removable, nonvolatile magnetic disk 152, and an optical disk drive 155 that reads from or writes to a removable, nonvolatile optical disk 156 such as a CD ROM or other optical media. Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive 141 is typically connected to the system bus 121 through a non-removable memory interface such as interface 140, and magnetic disk drive 151 and optical disk drive 155 are typically connected to the system bus 121 by a removable memory interface, such as interface 150.

[0030] The drives and their associated computer storage media discussed above and illustrated in FIG. 1, provide storage of computer readable instructions, data structures, program modules and other data for the computer 110. In FIG. 1, for example, hard disk drive 141 is illustrated as storing operating system 144, application programs 145, other program modules 146, and program data 147. Note that these components can either be the same as or different from operating system 134, application programs 135, other program modules 136, and program data 137. Operating system 144, application programs 145, other program modules 146, and program data 147 are given different numbers here to illustrate that, at a minimum, they are different copies.

[0031] A user may enter commands and information into the computer 110 through input devices such as a keyboard 162, a microphone 163, and a pointing device 161, such as a mouse, trackball or touch pad. Other input devices (not shown) may include a joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit 120 through a user input interface 160 that is coupled to the system bus, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB). A monitor 191 or other type of display device is also connected to the system bus 121 via an interface, such as a video interface 190. In addition to the monitor, computers may also include other peripheral output devices such as speakers 197 and printer 196, which may be connected through an output peripheral interface 190.

[0032] The computer 110 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 180. The remote computer 180 may be a personal computer, a hand-held device, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 110. The logical connections depicted in FIG. 1 include a local area network (LAN) 171 and a wide area network (WAN) 173, but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet.

[0033] When used in a LAN networking environment, the computer 110 is connected to the LAN 171 through a network interface or adapter 170. When used in a WAN networking environment, the computer 110 typically includes a modem 172 or other means for establishing communications over the WAN 173, such as the Internet. The modem 172, which may be internal or external, may be connected to the system bus 121 via the user input interface 160, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 110, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation, FIG. 1 illustrates remote application programs 185 as residing on remote computer 180. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.

[0034] C. Overview of SPL Framework

[0035] The SPL framework consists of a runtime component (an Interpreter) and a set of types. The runtime component mediates between a client application and one or more natural language analysis engines. The set of types defines the interaction between all elements in the system. In applications that utilize the SPL framework, an Interpreter instance is created at runtime and is initialized with a declarative schema that describes the semantic model of the features in the client application that rely on natural language inputs. This declarative schema is created by the developer along with the application code, and it describes the relationship among a number of semantic modeling types created by the developer and derived from types in the LOM. These semantic modeling types may contain procedural code that is not mentioned in the declarative schema and that, when instantiated by the Interpreter, places runtime-context-driven constraints on the instantiation of the types.

[0036] FIG. 2 is a block diagram of a semantic framework in accordance with one embodiment of the present invention. Semantic framework 200 includes an SPL client application 202, an SPL interpreter application 204, and a plurality of analysis engines 206. In general, the SPL client application 202 accepts text input, which may be input directly by a user (such as through a keyboard or other input device) or which may be received from a speech recognition system 208 or a text recognition system 210.

[0037] The speech recognition system 208 is a system that receives an audio input and produces a text output representative of the audio input. The text recognition system 210 is a system that receives a handwritten or scanned input and generates a text output representative of the handwritten or scanned input. In one embodiment, the speech recognition system 208 and the handwriting recognition system 210 are integrated with the client application 202.

[0038] In framework 200, a text input 212 string is input to SPL client application 202. Text input 212A refers to text output from the speech recognition system 208. Text input 212B refers to text output from handwriting recognition system 210. Text input 212C represents other text input, such as from a keyboard, from a memory buffer, or from any other input source. Hereinafter, reference numeral 212 is applied to the received text input, independent of source.

[0039] SPL client application 202 passes the text input 212 and application schema 214 of the SPL client application to SPL interpreter application 204. SPL interpreter application 204 passes text input 212 and application schema 214 to the plurality of natural language analysis engines 206 (shown as boxes Analysis Engine 1 through Analysis Engine N), each of which is designed to map the utterance to the Linguistic Object Model (LOM) 216. Any number of analysis engines 206 may be employed, and each engine 206 may use a unique analysis strategy for mapping the text input 212 to the LOM 216 and to the application schema 214.

[0040] In general, each analysis engine 206 applies its paradigm to the text input 212, and maps the text input 212 to the LOM 216 to produce a plurality of potential interpretations 218, which are returned to the SPL interpreter application 204. The SPL interpreter application 204 identifies one or more actual interpretations 220, and returns those actual interpretations 220 to the SPL client application 202, which can then act on the one or more actual interpretations 220.

[0041] In one embodiment, the analysis engines 206 derive only one possible interpretation 218; however, most semantic utterances allow for more than one possible interpretation, which may be resolved by the Interpreter 204 or the client application 202 with respect to the context of the utterance. In this case, the context is the domain of the SPL client application 202 and the objects it supports. The SPL interpreter 204, having received declarative schema 214 from the SPL client application 202, attempts to resolve the potential interpretations 218 against the declarative schema 214. The SPL interpreter application 204 can discard potential interpretations 218 that cannot be resolved against the declarative schema 214. The remaining interpretations (those that can be resolved against the declartive schema 214) are the actual interpretations 220. The SPL interpreter 204 attempts to instantiate each of the plurality of the actual interpretations 220 according to the declarative schema 214 of the SPL client application 202 by invoking the actual interpretation object 220 in the client application 202.

[0042] Depending on the implementation and configuration of the framework 200, controls 222 may be passed from the SPL client application 202 to the SPL interpreter application 204, instructing the SPL interpreter application 204 to perform further processing. Similarly, the interpreter application 204 may pass controls 224 to the analysis engines for further processing of the text input 212 relative to the LOM 216. Thus, the semantic framework 200 may process a text input iteratively to arrive at actual interpretations that corresponds to types defined within the domain of the SPL client application 202.

[0043] In general, the SPL client application 202, interpreter 204, and the analysis engines 206 may be located in a single computer. In an alternative embodiment, application 202, interpreter 204 and engines 206 may be located on different systems, such as on separate servers on a network.

[0044] The SPL interpreter 204 serves as an intermediary between the client application 202 and the analysis engines 206. The SPL programming language is intended to be intuitive to developers. In one embodiment, the language is built on top of C#, so the syntax will look familiar to developers. However, the SPL is adapted to express the LOM semantic structure and to perform linguistic analysis and can be implemented in C# directly or in any other object-based programming language.

[0045] As previously mentioned, the SPL framework includes a runtime component (the SPL interpreter 204), which mediates between natural language analysis engine(s) 206 and a set of types, which are created by the developer and derived from the types defined in the LOM. The set of types defines the nature of the interaction between all components of the framework.

[0046] The SPL Framework makes use of but does not include natural language analysis engines. It is designed to allow multiple analysis engines to be used simultaneously if desired. One might want to employ multiple analysis engines, for example, because some engines may be better at particular kinds of natural language input than others. Combining the outputs of the multiple engines may result in better overall performance and behavior.

[0047] For any given natural language input 212, the analysis engines 206 are expected to provide the interpreter 204 with linguistically possible interpretations 218 expressed in the system of types described in the declarative schema 214. The analysis engines 206 generally have access to the description of the semantic types in the declarative schema 214, but not to the actual types. Rather than producing actual objects, they produce potential interpretations (218), which are sets of instructions for building actual interpretations 220. The potential interpretations 218 produced by the analysis engines 206 become actual interpretations 220 only if the interpreter 204 succeeds in creating instantiations of the interpretations, where this includes running the procedural code of the types involved. The interpreter 204 attempts to resolve the possible interpretations 218 against the declarative schema 214, and, depending on the specific implementation, instantiates successfully-resolved interpretations in the client application 202 for further processing.

[0048] The back-and-forth between the client application 202, the interpreter 204 and the analysis engines 206 (including text input 212, declarative schema 214, potential interpretations 218, actual interpretations 220, and control flow 222 and 224) isolates conflicts and/or ambiguities. The framework and the LOM cooperate to free the programmer to concern him or herself with the application domain, rather than the linguistic analysis.

[0049] In general, the declarative schema may be XML code, Microsoft NET attributes, or Microsoft .NET attributes and the resolvable types themselves. Alternatively, the resolvable types may be coded so that the schema information can be inferred from the types using “reflection”. Reflection is the ability to determine what methods, fields, constructors, and so on, are defined for a class or an object. Reflection makes it possible to create dynamic programs.

[0050] Now that the framework has been introduced, it is important to understand the underlying linguistic object model from which the developer may derive his or her application specific set of types. The linguistic object model, in addition to being useful for natural language application development purposes, may be used to interact directly with a natural language semantic analysis system for arbitrary purposes.

[0051] D. Linguistic Object Model (LOM)

D1. Overview

[0052] The Linguistic Object Model (LOM) of the present invention is made up of a set of types, which are independent of the application domain or even the language. The present invention includes the set of types and the classes of linguistic expressions that the types are designed to model. The types are the declarative elements of the LOM.

[0053] It should be understood that applications of the present invention may be implemented in any number of ways, and that specific implementation details may vary from examples provided herein. However, the examples provided below are intended for illustrative purposes, and are by no means to be interpreted as limiting. Where appropriate, alternative methods or framework variances may be called out to further illustrate the versatility and robustness of the present invention.

[0054] In general, the LOM models the semantics of an utterance (what is said or written) in a domain independent way. The term “domain” as used herein refers to the SPL client application originating the natural language processing request. As used herein, the term “semantics” refers to the meaning or signification of spoken or written words. The term “utterance” refers to any finite sound or series of sounds and/or any written word or phrase detected by a software engine that the language engine attempts to analyze semantically. The term “syntax”, as used herein, refers to the grammatical or structural rules that define how symbols in a language are to be combined to form words, phrases, expressions, and other cognizable constructs.

[0055] LOM types can be accessed by a software application to map elements of an utterance to classes of linguistic expressions. For the purpose of clarity, the following discussion takes as primary the mapping from LOM types to classes of linguistic expressions. However, it should be understood that the mapping is a full-duplex (two-way) mapping from LOM types to classes of linguistic expressions and back. Both directions of this mapping are important for different tasks. Moreover, it should be understood that the LOM itself is language independent, such that no code changes are required to the LOM in order to model different languages. Such language-specific code changes are made, instead, in the analysis engines, not in the client application.

[0056] In general, the LOM specifies language abstractly, as a set of building blocks. The SPL application utilizes the building block framework to access the lexical semantic structure and the analysis engines in domain dependent way. Finally, it should be understood that the LOM does not require application schema to operate. The LOM can be utilized to model an utterance, and an analysis engine can provide a LOM mapping independent of the application schema. Thus, the LOM can be considered to be inside the analysis engines, and the LOM is a way to express natural language semantically. The analysis engines make decisions as to what the correct LOM expression is for a given utterance, effectively mapping the utterance to the LOM.

[0057] FIG. 3 shows a simplified block diagram of an analysis component 300 of the system of FIG. 2 according to an embodiment of the present invention. An analysis engine 302 receives flow controls 304, application schema 306 and text input 308. Using the LOM 310, the analysis engine 302 maps the text input 308 to the application schema 308 in order to produce one or more potential interpretations 312, which can be resolved by an SPL interpreter or by the client application from which the application schema 306 was received.

[0058] In general, the possible interpretations 312 are simply objects of particular types, represented as LOM objects. The analysis engines 302 may additionally map the LOM objects to the corresponding objects of the application schema before returning the possible interpretations to the interpreter or the client application, depending on the implementation.

[0059] Prior to discussing the structure of the LOM in detail, it is useful to develop at least a cursory understanding of the base types utilized by the semantic programming language. In general, the semantic programming language can operate over any number of different semantic object models, but is specifically optimized to operate with the structure of the LOM. At this time, the LOM is the particular semantic object model that offers the best compromise between programming intelligibility (from an application developer's perspective) and linguistic coverage (namely model elements required for application scenarios such as command-and-control, question-answering, and the like).

D2. Semantic Programming Language Types

[0060] The semantic programming language (hereinafter referred to as “SPL”) is intended to assist software application developers to implement natural language programs. Since most developers are not experts in semantic analysis or linguistics, the SPL provides a framework and a programming language for non-linguist developers to deal with natural language semantics in largely intuitive ways.

[0061] The SPL and an accompanying compiler facilitate programming of natural language client applications to the LOM. The SPL is designed to hide many of the underlying details of the linguistic framework in order to make it easier for developers to write code that interacts properly with the Framework.

[0062] Although the SPL can be the standard front-end for developers making use of the Framework, the SPL is not required. A developer can target the Framework directly, by creating types that implement the various Framework interfaces, by inheriting from types that implement the various Framework interfaces, and by providing application schema to the Interpreter. Alternatively, this may be done indirectly, such as by other means of authoring Framework-compatible code, as through, for example, a visual forms-based design tool.

[0063] In general, the LOM is implemented as a class library of the SPL. This is similar to the way that the C Runtime Library and the Standard Template Library (STL) form the standard library of, for example, Microsoft® Visual C++®, which is an application designed to facilitate software development and which was created by Microsoft Corporation of Redmond, Wash. The terms Microsoft® and Visual C++® are trademarks owned by Microsoft Corporation of Redmond, Wash.

[0064] The semantically meaningful types in SPL are those types that participate in the modeling of the semantics of incoming utterances and in modeling the application commands to which those incoming utterances correspond. Semantically meaningful types are the types that SPL authors can derive from and specialize to their application domains. The semantically meaningful types in SPL are Entities, Frames, Restrictions, Commands, and Denoter Objects. Functional types in SPL are Phrases and Slots. Each of these types is discussed separately below.

[0065] In general, the SPL framework types define all aspects of the interactions between the client application, an SPL interpreter, and one or more natural language analysis engines. The phrase “all aspects of the interactions” refers to the interfaces that the various components must implement, the base classes from which the various components inherit, and the types of data passed between components of the system. In one embodiment, the framework types are implemented as types in the NET Framework, which is a framework that was created by Microsoft) Corporation of Redmond, Wash. The SPL types can be arranged into several namespaces. In one embodiment, the SPL types are arranged into several namespaces, which are all subnamespaces of, for example, System.NaturalLanguageServices or System.NaturalLanguage namespace. As used herein, “namespace” refers to a context in which names (identifiers) are defined. Within a given namespace, all names must be unique.

[0066] For the sake of clarity, the discussion below introduces the SPL types, introduces the LOM in detail, and then returns to detail the SPL. Throughout the text, examples are used, where appropriate, to illustrate the invention. For the most part, examples tend to derive from a simple natural language utterance, Send mail to Bob. Given this utterance, an application written according to the LOM and using the SPL can generate interpretations based on the text input. The generated interpretations can then be resolved against the natural language application to identify and execute actual interpretations of the instruction.

[0067] An Entity is an object of type Entity, meaning an entity can include data members, properties and methods. SPL Entities are objects whose type derives from class Entity and is used mainly to model the semantics of noun phrases and adjective phrases. SPL Entities may host frames or restrictions (both described below) via the “with” syntax. Additionally, SPL Entities may include an optional “Denoted By” clause, which introduces a privileged data member of type “Denoter” (described below). The privileged data member, introduced by the “Denoted By” clause, can be used by an SPL interpreter to map entities to actual natural-language words.

[0068] A Frame is a class, which models the semantics of semantic events, where the semantic event can be expressed either as verbs or nouns. SPL frames are classes that derive from Frame. In general, Frames can apply to Entities, so a Frame can have a “Denoted By” clause, as well as lists of “slots” (described below) containing frame arguments. Additionally, Frames may host restrictions via the “with” syntax. In one embodiment, head words for a Frame may be defined by a developer to create new Frame types. In an alternative embodiment, developers inherit from existing frames, and derive the desired headwords from inheritance. In another embodiment, developers can specify headwords in a manner similar to how denoters are specified.

[0069] Restrictions generally model oblique arguments, modifiers, and other semantic elements. SPL restrictions are classes that derive from class Restriction. Restrictions, like frames, have lists of slots containing arguments. Additionally, SPL Restrictions may host other Restrictions via the “with” syntax.

[0070] SPL commands are classes that derive from class Command. Commands are purely domain dependent, meaning that they depend on the specific natural language application to which they are associated. In general, domain dependent commands have no role in modeling the semantics of the input, and thus commands play no role in the LOM. Instead, commands model actions in the application.

[0071] Additionally, commands have an optional “uses” clause, which introduces a privileged data member of type Frame. The “uses” clause is the crucial link between the domain-independent input and the desired domain-dependent action.

[0072] Denoter objects are structs of type Denoter. In practice, a lexicon is created that maps from each word used as a denoter in a SPL program to a corresponding list of Denoters, so the Denoter object does not need to store a string list. There is one Denoter Object per natural language (an ENGLISH field, a JAPANESE field, and the like.). Denoter objects act as localization tables for entities. Like commands, denoter objects are purely domain dependent. However, Entity does have a field of type Denoter, which exists only so that the application can examine the Denoter object to determine why the Entity was suggested by an analysis engine.

[0073] The functional types in SPL are types that serve some modeling purpose, but that cannot be specialized. Additionally, other classes and types cannot be derived from the functional types.

[0074] The functional type “Phrase” encapsulates information about a portion of a text string input underlying some semantic object. Type Phrase allows software developers to perform ad hoc manipulation and examination of the original input string from inside structured representations of the semantics of that input string.

[0075] In one embodiment, the functional types “Slots” are objects of type Slot that hold entities, frames, restrictions or denoter objects, possibly along with some auxiliary information. For instance, slots corresponding to gaps in relative clauses contain entities marked as “backreferences”. In an alternative embodiment, the Entity, Frame, or other reference is placed where a slot is expected. In another alternative embodiment, the Slot object is omitted along with its auxiliary information, and the Entity, Frame or other reference is used directly.

D3. Lom Types

[0076] Having reviewed the types that define the SPL semantic model structure, it is possible to discuss the LOM in detail. In general, the LOM types and the classes of linguistic expressions modeled by the types include Entities, Frames and Restrictions.

[0077] a. Lom Entities

[0078] While a large part, perhaps the majority, of an SPL programmer's job revolves around designing an array of domain entity types and gathering the correct localization information for each of those types, from the LOM's perspective, entities are straightforward. In many cases, the “head word” of the phrase is the head word of the entity. The head word normally corresponds to the lemma of the syntactic head of the phrase the entity models. The lemma denotes a canonical representation for different forms of a word. For example, the terms walks, walked, and walking share the lemma walk.

[0079] Regardless of the spoken language used, the general rule for all languages is that NPs become LOM entities. The head word of the entity is the lemma of the NP's head noun.

[0080] In general, coordination of entities is expressed in the LOM via the type “CoordinatedEntity”. A code snippet of illustrating an instantiation of type CoordinatedEntity is shown in Table 1.

[0081]

TABLE 1
CoordinatedEntity.
	Entity CoordinatedEntity
	{
	Entity entities[ ];
	CoordRelation relBetweenEntities;
	}
	enum CoordRelation
	{
	And,
	Or,
	ExclusiveOr
	}

The goal of the LOM with respect to coordination is to minimize semantically-irrelevant bracketing ambiguities. Thus, for instance, a text input of X and Y and Z is represented as the flat list X AND Y AND Z and is not ambiguous between the right-associative X AND [Y AND Z] and the left-associative [X AND Y] AND Z. When there is true bracketing ambiguity, however, the LOM preserves the ambiguity. For example, for the phrase show cars with 4WD and ABS or AWD, both 4WD AND [ABS OR AWD] and [4WD AND ABS] OR AWD are possibilities. Of course, in this particular case, only the second representation is likely to make sense, but that is for the application to decide, rather than the LOM.

[0082] Pronouns are modeled in the LOM as objects of type “PronounEntity”. An illustration of an instantiation of a pronoun entity according to an embodiment of the present invention is shown in Table 2.

[0083]

TABLE 2
PronounEntity.
	entity PronounEntity
	{
	Entity potentialAntecedents[ ];
	}

The LOM provides an interface for anaphora resolution through the “potentialAntecedents” field within PronounEntity. The term “anaphora” refers to the relation between multiple words or phrases referring to the same Entity. The potentialAntecedents field can be optionally filled in with a list of previously-resolved Entity objects that are linguistically possible antecedents. The list is ranked in decreasing order of likelihood. The linguistic agreement information, which is the most important factor in anaphora resolution, can be accessed by the application developer through the object of type “AgreementInfo” that is attached to every Entity. An example of a struct AgreementInfo is provided in Table 3.

[0084]

TABLE 3
STRUCT AgreementInfo
	struct AgreementInfo
	{
	bool firstPerson;
	bool secondPerson;
	bool thirdPerson;
	bool singular;
	bool plural;
	bool feminine;
	bool masculine;
	bool neuter;
	bool honorific;
	bool humble;
	}

Only AgreementInfo fields that are unambiguously true with respect to a given entity are associated with that entity's AgreementInfo object. In other words, the LOM makes no attempt to represent disjunctive agreement features. For example, the term cat would have “thirdperson” and “singular” associated with its AgreementInfo object. The phrase she is is associated with “thirdPerson”, “singular”, and “feminine” in its AgreementInfo object. In French, the term “vous” is associated with “secondPerson”. In Spanish, the term perro is “thirdperson”, “singular”, and “masculine”, each of which are unambiguously true with respect to the given entity perro, and therefore are associated with that entity's agreement object.

[0085] Demonstratives such as “this” and “that”, which can be used as independent NPs, become objects of type DemonstrativeEntity. An illustration of an entity DemonstrativeEntity is provided below in Table 4.

[0086]

TABLE 4
DemonstrativeEntity.
	entity DemonstrativeEntity
	{
	DemonstrativeType type;
	}
	enum DemonstrativeType
	{
	Near,
	Middle,
	Far
	}

Since objects of type DemonstrativeEntity are derived from Entity, they inherit the AgreementInfo objects, allowing words like this and that to be distinguished. In general, this inheritance allows the system to have the capability of distinguishing correctly between such elements in English, French, German, Japanese, Spanish, and numerous other languages.

[0087] Another related type is the NamedEntity type. The syntax for a NamedEntity is as follows.

• • [0088] namedentity OlapNamedEntity uses ExcelAddin.FuzzyolapCubeRecognizer;
    In general, NamedEntity types are based on a separately defined class that inherits from a NamedEntityRecognizer class. The NamedEntityRecognizer types are passed along with the schema, and an analysis engine can use them to call back into the client code to dynamically identify application object references in the utterance.

[0089] b. Lom Frames

[0090] In one implementation, for all languages, clauses become LOM Frames; however, this is not necessarily true for all implementations. Conceptually, a Frame comes from a clause, but there need not actually be a clause present in the input. The head word of the frame is the lemma of the verb heading the clause. For example, analyzing the phrase “Send mail to Bob” would result in “send mail” being associated with an LOM Frame, where “Send” is the lemma of the verb heading the clause and is therefore the head word of the frame.

[0091] It should be understood that the Restrictions can be conceptualized as providing for a default behavior. However, such behavior is not necessarily enforced. The functionality is implementation specific.

[0092] Slots can be filled by entities or frames, so default slots can be either noun phrases or clauses. In addition, NPs may be headed by an empty pronoun (PRO). If PRO points to referents in another clause, the head of that clause will be interpreted as the head of the NP entity. If PRO has no referents, it will be interpreted as some entity, (such as someone or something).

[0093] In one embodiment, assuming there is a subject contained in the clause, the subject of the clause fills the “Doer” restriction. If there is no subject, there is no “Doer” restriction. “Doer” represents a first participant in an event, with semantics loosely described as doer, agent, actor, instigator or cause of the event or state named by the verb. Examples of verb clauses where a portion of the clause maps to the “doer” restriction of the frame appear below in Table 5.

[0094]

TABLE 5
Verb Clause with a Subject.
	Instant message opens.
	Robin is on my buddies list.
	Amazon offers wish list capabilities.
	[PRO] open the file
	Having a program associated with a file ensures
	easy opening.

The underlined words or phrases are those that are mapped to the Doer slot. This is true in both transitive and intransitive frames, corresponding to transitive and intransitive verbs.

[0095] If there is an object in the clause, the object is mapped to a second slot of the frame called the “DoneTo” restriction representing the second syntactic participant in the event. The semantics may be loosely understood to refer to the object that is affected by the event or state named by the verb. The underlined phrases of Table 6 map to the “DoneTo” restriction.

[0096]

TABLE 6
The “DoneTo” Restriction
	Outlook has my buddies list.
	Amazon offers wish list capabilities.
	[PRO] open the file.
	Preferences  include  having   a   program
	associated with a file.

[0097] In one implementation, indirect objects can be understood to be the beneficiaries of the action. In one embodiment, indirect objects may be mapped to a Beneficiary restriction. The Beneficiary restriction generally models verbal arguments that express the person on whose behalf or in whose place an event was performed. The beneficiary slot is illustrated briefly by the underlined pronouns contained in Table 7.

[0098]

TABLE 7
Beneficiary Slot.
	Open me a new file.
	Play her some tunes

[0099] A Beneficiary restriction (or in an alternative embodiment, a “slot”) may be set to the entity modeling a noun phrase that is interpreted as a beneficiary. Table 8 illustrates a code block of the beneficiary restriction.

[0100]

TABLE 8
Beneficiary Retriction.
	restriction Beneficiary<benef := Entity>
	{
	}

[0101] The beneficiary restriction, sometimes referred to as “benefactive”, overlaps with allocation in English, especially on singular objects of “for” prepositional phrases. Some overlap may also occur in other languages. When applied to frames, the beneficiary restriction is apparent from the following sentence.

• • [0102] I baked a cake for my mother. PP [for]

[0103] In general, the beneficiary restriction models verbal arguments in most languages. Table 9 illustrates the beneficiary restriction in a few sample languages.

[0104]

TABLE 9
Beneficiary Restriction.
	ENGLISH:
	Preposition For
	Applies to indirect objects that are not
	Goals (cannot be paraphrased  by  a  “to”
	prepositional phrase)
	I baked her a cake -> I baked a cake
	for her.
	NOT: I gave her a book (cf.  I gave a
	book to her, cf. Goal)
	I baked a cake for her.
	I baked her a cake.
	FRENCH
	Preposition pour
	GERMAN
	Indirect objects:
	Ich schicke ihr eine Nachricht.
	Preposition für
	Das ist eine Nachricht für sie.
	JAPANESE
	NP-  NP
	NP-  ...VP
	Subjects  of a fixed clausal (small clause)
	construction,  comparable  to  the  English
	bake  a  cake  [for her to have].   In
	contrast,  verbs that take  a  Goal  argument
	mark it with the dative particle,  e.g.  give
	her-DAT book-ACC
	SPANISH
	Preposition para
	Trajimos la lista de regalos para Fernando.

[0105] Generally, restrictions may be subjects, direct objects, indirect objects, oblique arguments, modifiers, and the like. In SPL, a frame can take any restriction (with exceptions noted below). However, the LOM uses the grammar to prefer restrictions in two ways. First, an oblique argument may be a restriction type associated with a Lexical Semantic Structure class of which the verb is a member (this is discussed in greater detail below) Second, an oblique argument may be idiosyncratically associated with an individual verb; that is, the argument does not bear any of the restriction relations to its clausal head. The arguments are assigned to the Default restriction (discussed below) and are identified by their lexical head.

[0106] Coordination of frames is done in two different ways, depending on the context. “Top-level” coordinated frames (i.e., those that come from matrix verbs) are represented as objects of type CoordinatedFrame, parallel to CoordinatedEntity (described above). An illustrative example is shown in Table 10 below.

[0107]

TABLE 10
CoordinatedFrame.
	frame CoordinatedFrame
	{
	Frame	frames[ ];
	CoordRelation	relBetweenFrames;
	}

Generally, frames that appear on entities (via the “with” syntax) behave as restrictions. As described below, that means that conjunctions are expressed by triggering multiple restrictions, while disjunctions are expressed by multiplying out the host entity into a CoordinatedEntity.

[0108] As previously discussed, in one embodiment, Frames may serve as restrictions on entities to model natural language relative clauses. When frames are attached to entities via the “with” keyword, the frame imposes a restriction on the entity, which is referred to as a “frame-based restriction”. In a vast majority of cases, one slot in a frame corresponds to a natural language gap bound by the head noun. In the LOM, this translates into the frame-based restriction receiving a reference to its host entity in one of its slots. Inclusion of a reference to the host entity in a slot of the frame-based restriction can be referred to as a “backreference”. Since such “backreferences” permit reentrance into the otherwise tree-like LOM representations, slots that correspond to gaps have their isBackreference flag set to true. (This flag is simply a convenience for processes that walk over LOM representations.) For example, in Table 11 below, a frame-based restriction is resolved against the phrase “files that Billy opened yesterday”.

[0109]

TABLE 11
Frame-Based Restriction

In table 12, a frame-based restriction is resolved against the phrase “people who work at Company”.

[0110]

TABLE 12
Frame-Based Restriction

In table 13, a frame-based restriction is resolved against the phrase “people I have sent mail to”.

[0111]

TABLE 13
Frame-Based Restriction

It is important to note that the reentrances introduced by frame-based restrictions cause difficulties for the resolution process of SPL. Specifically, an entity is not fully resolved (and thus in SPL does not technically “exist”) until all of its restrictions have been fully processed. However, one of an entity's restrictions can be a frame that takes the entity itself in one of its slots. A situation thus arises where the entity object needs to be examined by the code that defines the frame, yet the entity remains in an undefined state until some point after the resolution of the frame finishes. This issue is discussed in greater detail below in Section E.4.

[0112] In an alternative embodiment, Frames do not have slots, but instead use “Doer” and “DoneTo” restrictions as described above. In such an instance, a new restriction may be defined based on the frame, and restriction clauses for “Doer” and “DoneTo” can be applied to that new restriction. Thus, restrictions present an alternative way of handling frame arguments. In the following discussion, for the sake of brevity, reference may be made to only one such implementation, but either implementation may apply.

[0113] c. Lom Restrictions

[0114] Unlike entities and frames, coordination of restrictions is not represented through the use of “compound” types such as CoordinatedEntity and CoordinatedFrame. Instead, the semantics of SPL are exploited to represent restriction conjunctions, while restriction disjunctions are reduced to entity or frame disjunctions.

[0115] SPL assigns a conjunction or intersection semantics to two restriction clauses successfully triggering sequentially on the same host; therefore, linguistic conjunction of material that is modeled with restrictions is handled by simply triggering two or more restrictions in sequence. Linguistic disjunction of material modeled with restrictions, on the other hand, has no convenient counterpart in SPL semantics. Such disjunctions, then, “bubble up” to the next entity or frame above the restriction (usually the host), giving rise to CoordinatedEntity or CoordinatedFrame objects at that level.

[0116] For instance, for the phrase “mail from Kim or to Robin”, there is an entity host, “Entity(mail)”, and two restrictions, “Source(Entity(Kim))” and “Goal(Entity(Robin))”. Since the two restrictions are coordinated with the disjunction “or”, the disjunction should bubble up to the host, “Entity(mail)”, resulting in the mapping illustrated in Table 14.

[0117]

TABLE 14
RESTRICTION COORDINATION

This code produces two copies of Entity(mail).

[0118] An Accompaniment restriction models an additional member or members in some group. Often, accompaniment can be paraphrased by a conjunction. For example, the phrase customers along with their birthdates can be paraphrased as customers and their birthdates. For reciprocal-event-denoting entities, the accompaniment restriction models an additional participant in the event. Often, such nominals have corresponding frames (e.g. correspond, meet, chat, and so on). The accompaniment restriction also models prepositional phrases in noun phrases such as correspondence with my manager, an appointment with Kim, meeting with Tim (emphasis added), a chat with Sue, and so on. An example of the syntax of an Accompaniment restriction according to an embodiment of the present invention is illustrated in Table 15.

[0119]

TABLE 15
ACCOMPANIMENT.
	restriction Accompaniment<accomp := Entity>
	{
	}

[0120] The Accompaniment restriction can also model additional who or what participants in the context of a Frame. For example, the phrase “chat with Robin” invokes the “Chat” frame with the phrase “with Robin” as an accompaniment restriction.

[0121] The accompaniment restriction may also be assigned to a slot within the entity modeling the noun phrase that is interpreted as accompanying the host. Alternatively, the accompaniment restriction can be set to the “who” or the “what” slot.

[0122] In some instances, it may be desirable to compile a list of cases of “with” as entity lists, which are semantically equivalent to conjunctions. To the extent that equivalent accompaniment expressions exist in other languages as well, it may be useful to compile entity lists for those expressions as needed.

[0123] With respect to possessives that can be modeled as accompaniment, it may be desirable include them in entity lists as well. For example, “email with attachments” is an accompaniment-style possession, as opposed to “email's attachments” which is a possessor-style possession. In some instances, these may be treated as linguistically complementary. Additionally, phrases such as “an email that has attachments” can also be modeled as accompaniment restrictions.

[0124] Subject reciprocals can also be folded into accompaniment restrictions. An example of a subject reciprocal is “John chatted with Mary” as compared with “John and Mary chatted”. Lexically, these two expressions are easily identified. Similarly, object reciprocals, such as “Merge File A and File B” as compared with “Merge File A with File B”, are readily identifiable. It may be desirable to incorporate such subject and object reciprocals into accompaniment normalization in the LOM.

[0125] The accompaniment restriction extends to many languages, particularly with respect to prepositional phrases such as “along with” or “together with”. In French, German, Japanese, Spanish, and other languages, a similar accompaniment restriction can be employed. Table 16 illustrates such accompaniments.

[0126]

TABLE 16
Accompaniment Restrictions
	(along|together) PP[with] (English)
	((tout) ensemble) PP[avec] (French)
	PP[mit] + Dative (German)
	“Er kommt mit den Kindern.”
	Entity Hosts: (Japanese)
	NP-   NP
	NP-    NP
	Frame hosts: (Japanese)
	NP- ... VP
	NP- ...   ... VP
	PP[con] (Spanish)

[0127] An allocation restriction, such as that illustrated in Table 17, generally models an entity to which the host entity is distributed or models an entity that exists or was created on the host entity's behalf.

[0128]

TABLE 17
Allocation Restriction.
	restriction Allocation<alloc := Entity>
	{
	}

When the allocation restriction models an entity to which the host entity is distributed, an example of such a restriction might be “online profile for each fund”, “schools for linguistics”, or “application for a job”. The underlined portion illustrates the allocation restriction. When the allocation restriction models an entity that exists or was created on behalf of the host entity, the semantic utterance might be “a cake for my mother” or “party for my manager.” In both instances, the allocation restriction adds specificity to the entity. Table 16 illustrates code for an embodiment of an allocation restriction. An allocation restriction can be set to the entity modeling the noun phrase that is interpreted as allocated to the host using the slots.

[0129] In general, the allocation restriction may apply to allocation to singular as well as plural entities. The allocation restriction is in complementary distribution with the Beneficiary in English. Only an entity hosts an allocation. Only frames host a beneficiary, especially on singular objects of for prepositional phrases. In English, this preposition may be used in a number of ways. For example, in packets for a specific destination it indicates a purpose, whereas in application for which you are enabling authorization checking it is a type of allocation. Similarly, tabs for taskpad views, checkbox for the type of service, and area code for Madison, Wis. all represent allocation restrictions. In German, fur expresses allocation, inter alia. In Spanish, the corresponding preposition is para:the phrase “una escoba para la cocina” illustrates an allocation restriction.

[0130] An “AsBeing” restriction on a Frame models a property or capacity assigned to the object slot of the frame. Only modifier restrictions modeling an adjective phrase map into the restriction version. Table 18 provides two code samples of the AsBeing restriction.

[0131]

TABLE 18
AsBeing Restriction.
	restriction AsBeing<asbeing := Entity>
	{
	}
	restriction AsBeing<asbeing := Modifier>
	{
	}

In general, the LOM models the semantic relationship between lemmas of an utterance. The “AsBeing” restriction attempts to model the prepositional phrase “as”. For example, the phrase “Save the file as a text file” is similar to “Save the file to a text file”. “Set my status as busy” is similar to “Set my status to busy.” The AsBeing restriction models a property or capacity assigned to the object slot of the frame. Here, the AsBeing restriction models the restriction “as” to “text file”, which is the property assigned to the object slot of the frame. Alternatively, it may be possible to apply this functionality to a Denoter, rather than to an Entity. Table 19 illustrates an example of the AsBeing object in English, German, Japanese, and Spanish.

[0132]

TABLE 19
AsBeing Examples.
	ENGLISH
	PP[as]: Save the file as text.
	Make me an administrator.
	Mark all messages unread.
	GERMAN
	PP[als]: Speicher die Datei als Text.
	JAPANESE
	-to complementizers
	-to site adverbials
	SPANISH
	PP[for]:  para

[0133] A cardinal restriction is one that models cardinality as expressed by numeric quantifiers. Slots and fields may be set to the floating point value of the numeric quantifier. Indefinite articles such as “an” and “a” may be modeled as “one” in some cases. Table 20 illustrates a cardinal restriction.

[0134]

TABLE 20
Cardinal Restriction.
	Restriction Cardinal
	{
	float number;
	}

Additionally, it may be desirable in certain instances to block cardinal on units of time (such as “in 3 hours”, and so on). With respect to time units in particular, blocking the cardinal restriction should not conflict with Time-type objects (at least in English) because the introduction of a time quantity typically requires a prepositional phrase, such as “in 3 hours” or “for 3 minutes”, and so on. Table 21 illustrates some exemplary expressions that can be mapped to cardinal restrictions.

[0135]

TABLE 22
Example Expressions illustrating Cardinal Restrictions.
	ENGLISH
	3 cats
	ninety dollars
	2.5 kilos
	FRENCH
	3 chats
	cinq francs
	2,5 kilos
	GERMAN
	3 Mails
	fünf Euros
	2,5 Kilos
	JAPANESE
	2.5
	...   (floating quantifiers)
	SPANISH
	3 gatos

[0136] Another type of restriction, “Comparison”, models comparisons of an entity with another explicitly identified entity. The syntax for a Comparison restriction is illustrated in Table 23.

[0137]

TABLE 23
Comparison Restriction.
	Restriction Comparison<dimension := Modifier,
	refpoint := Entity>
	{
	}

The comparison restriction is not used for implicit comparisons, such as where one of the entities to compare is not explicitly referenced. For example, “a bigger file” suggests an implicit comparison, which does not invoke the comparison restriction.

[0138] The comparison restriction may be applied to a dimension slot, where the dimension is set to a modifier restriction modeling an adjective phrase. This modifier restriction will typically have a “degree” restriction with its degree field set to “more”, “less” or “same”, for example. A “refpoint” field is set to the entity to be compared with the host entity.

[0139] Depending on the specific implementation, superlatives that explicitly name a comparison class may require special attention. For example, the phrase the tallest girl in the class may result in the class being called out as a refpoint for comparison, or alternatively the class may be called out as a location on girl. Various other superlative expressions may also require special attention. For example, the phrase my daughter is tall for her age and the Spanish equivalent mi hija es alta para su edad present a similar problem from the perspective of the LOM.

[0140] Table 24 provides some exemplary expressions that can be modeled by the comparison restriction.

[0141]

TABLE 24
Example expressions modeled by the
comparison restriction.
	ENGLISH
	a file bigger than mydoc.txt
	documents  that  are  less  relevant  than
	mydoc.txt
	watches as expensive as the Rolex X-55J
	FRENCH
	des livres plus chers que ce livre
	GERMAN
	PP[als]
	Eine Datei,  die  kleiner  ist  als
	mydoc.txt.
	[ebenso/genauso/so/ [AJP]  wie]
	Die  Datei  ist genauso gross wie
	mydoc.txt.
	JAPANESE
	mydoc.txt
	X-55J
	SPANISH
	un archivo más grande que mydoc.txt

[0142] A conditional restriction models a condition expressed within an utterance. Table 25 illustrates a conditional restriction syntax.

[0143]

TABLE 25
Conditional Restriction.
	restriction Conditional<condition := Frame>
	{
	ConditionType type;
	}

Like previous examples, the conditional restriction can be modeled in most languages, including English, French, German, Japanese and Spanish (among others).

[0144] A default restrictiondoes not model any particular class of constructions, but simply provides an interface to portions of the underlying linguistic analysis that have not yet been claimed by other LOM objects. Table 26 provides an example of the default restriction syntax for one possible implementation of the present invention.

[0145]

TABLE 26
Default Restriction
	Restriction Default
	{
	LinguisticAnalysis analysis;
	}

[0146] Another possible variant of the Default restriction takes a single Entity as its slot. This variant of the Default restriction makes it possible for any relationship between this single Entity and the object hosting the restriction.

[0147] It is important to note that in general a restriction can have patterns associated with it. Such pattern associations can enable the LOM consumer to communicate with an LOM producer (analysis engine) regarding which linguistic constructs to identify. A simple example would be string-based patterns. For example, a Source restriction usage could have a pattern of [“due to”+X] to ensure that an analysis engine (LOM producer) maps that pattern to a Source restriction. By applying pattern associations to the linguistic analysis, the programmer (author) can choose to do lower-level reasoning over the user input. Unlike other LOM types, there is no cross-linguistic normalization implied with the Default restrictions.

[0148] Depending on the implementation, it may be necessary to define a single interface (for example, “ILinguisticAnalysis”) that can expose anything from full parsing results to simple strings. In general, patterns may correspond to different ways that parts of an utterance might be exposed through an ILinguisticAnalysis. In a preferred embodiment, there is a range of default restrictions, one for each kind of analysis engine.

[0149] A Degree restriction attaches only to modifier restrictions that model adjective phrases. Table 27 illustrates the syntax for the degree restriction and the DegreeType enumeration.

[0150]

TABLE 27
Degree Restriction.
	restriction Degree
	{
	DegreeType degree;
	}
	enum DegreeType
	{
	More,
	Most,
	Less,
	Least,
	Same,
	High,
	Low
	}

The values of the DegreeType enumeration then represent various possible qualifications to the meaning of the adjective phrase. The degree field is set to the appropriate value.

[0151] In some instances, it may be desirable to recognize the low value of DegreeType by retrieving both a clausal negation and a high-type adverb at the same time. For example, the expression “not very big” refers to a low value of DegreeType expressed through a negation (not) and adverb (very). Ignoring the negation would lead to an incorrect interpretation of the utterance. Table 28 illustrates some exemplary phrases that can be modeled using the degree restriction.

[0152]

TABLE 28
Example Phrases Implicating Degree
Restriction.
	ENGLISH
	More: bigger, more relevant
	Most: biggest, most relevant
	Less: less relevant
	Note that smaller is not modeled as “less
	big”, but as “more small”. The LOM does not
	model any notion of scalar antonyms.
	Least: least relevant
	Same: as big
	High: very big, extremely popular
	Low: not very big
	GERMAN
	More: gröβer, relevanter, mehr relevant
	Most: gröβte/n, am Relevantesten
	Less: weniger relevant, weniger wichtig
	Least: wenigβte/n
	Same: genauso/ebenso relevant
	High: sehr klein, extrem dick
	Low: nicht sehr dick

It will be understood by a worker skilled in the art that other Degree restriction types exist in English and German, and that such restriction types also exist in most languages. The Degree restriction can be accessed using almost any language.

[0153] A Direction restriction models a direction of motion or an orientation of spatial position. Table 29 provides an example of the Direction restriction and its associated enumerations.

[0154]

TABLE 29
Direction Restriction and Associated
Enumerations.
	restriction Direction<landmark := Entity>
	{
	DirType myDirType;
	OtherDirectionType other;
	}
	enum DirType
	{
	Up,
	Down,
	Backward,
	Forward,
	Around,
	In,
	Out,
	Other
	}

[0155] The Direction type (“DirType”) field of the slot can be set to the appropriate enumeration value. In some instances, other enumerated values may be desirable. For example, the command “turn” has an unspecified direction; however, “turn” appears to expect a direction as an argument. Thus, it may be desirable to provide an enumerated value for “Unspecified” so as to distinguish such an expression from other, depending on the implementation. Values that are conflated in verbs may be stored as new object representations on the lexical entry. It is also important to understand that the Direction restriction includes objects of direction (prepositional phrases) and directional adverbs, independent of the attachment site. Table 30 provides some examples of phrases that can be modeled by Direction restrictions.

[0156]

TABLE 30
Example Phrases Modeled by Direction
Restriction
	ENGLISH
	up (up, raise, elevate, increase)
	down (down, lower, decrease, plummet)
	forward (advance, proceed)
	backward (back, backward, retreat, recede,
	retract)
	around (rotate)
	in (insert)
	out (extract)
	other (diagonal, left, turn)
	GERMAN
	up (hoch, anheben, erhöhen)
	down (runter, senken)
	forward (vorwärts, nach vorn)
	backward (rückwärts, zurück)
	around (drehen., rotieren)
	in (einfügen)
	out (extrahieren)

It will be understood by a worker skilled in the art that other Direction restriction types exist in English and German, and that such restriction types also exist in most languages.

[0157] An Example restriction models exemplars of an entity type, a frame or a restriction. Table 31 illustrates the syntax for each such Example restriction type.

[0158]

TABLE 31
Example Restriction.
	restriction Example<example := Entity>
	{
	}
	restriction Example<example := Frame>
	{
	}
	restriction Example<example := Restriction>
	{
	}

In some implementations, it may be desirable to have a SimilarTo restriction for attaching structures such as the following:

• • [0159] I want to find vendors, for example Volt.
  • [0160] I want to find vendors, Volt, for example.
    In another embodiment, it may be desirable to provide an additional slot for the object (the what) for which the exemplar is an example. For example, the phrase This program exemplifies solid coding techniques may require an extra slot for modeling the phrase “solid coding techniques”. In general, the Example restriction can be understood to model similes. Table 32 provides some phrases that can be modeled by the Example restriction.

[0161]

TABLE 32
Example Phrases Modeled by Example
Restriction.
	ENGLISH
	“like”
	Show me cars like the Honda
	Which CEO dances like a monkey?
	What does a butterfly look like?
	“as”
	“such as”
	GERMAN
	wie
	SPANISH
	como

It will be understood by a worker skilled in the art that other Example restriction types exist in English, German and Spanish, and that such restriction types also exist in most other languages. The Example restriction can be accessed using almost any language.

[0162] An Extent restriction models an entity with respect to which some notion of extent in space is measured. Table 33 illustrates the syntax of the Extent restriction.

[0163]

TABLE 33
Extent Restriction.
	restriction Extent<extent := Entity>
	{
	}

In general, the extent field of the slot is set to the Entity that models the measure of the extent. In one embodiment, the object of the extent prepositional phrase is independent of the attachment site within the utterance. Table 34 provides an example of an English and a Spanish term that can be modeled by the Extent restriction.

[0164]

TABLE 34
Example Phrases Modeled by Extent
Restriction.
	ENGLISH
	along
	SPANISH
	por
	Mi hermana va por la calle San Juan.

[0165] A Goal restriction models a goal of motion (metaphorical or physical) or an end state of a change of state with respect to an Entity or a Frame. Table 35 illustrates the syntax of the Goal restriction according to an embodiment of the present invention.

[0166]

TABLE 35
Goal Restriction.
	restriction Goal<goal := Entity>
	{
	}

The Goal restriction can be associated with one or more enumeration values. The field “DirType” (defined in Table 29 above), for example, can be the enumeration values of the Goal restriction, which can be set to the appropriate enumeration value Table 36 provides some phrases that can be modeled by the Goal restriction.

[0167]

TABLE 36
Example Phrases Modeled by Goal
Restriction.
	ENGLISH
	to
	FRENCH
	à
	GERMAN
	für
	JAPANESE
	NP-
	SPANISH
	para
	Hay vuelos para La Paz todas las semanas.

[0168] It will be understood by a worker skilled in the art that other Goal restriction types exist in most languages. The Goal restriction can be accessed using most languages.

[0169] An Iteration restriction models repetition of an action. Table 37 illustrates the syntax of the Iteration restriction.

[0170]

TABLE 37
Iteration Restriction.
	restriction Iteration
	{
	IterationType type;
	float     times;
	}
	enum IterationType
	{
	Count,
	Never,
	Rarely,
	Sometimes,
	Often,
	Always
	}

[0171] In one embodiment, the Iteration restriction may be incorporated into a Recurrence field of the time restriction. In general, the field of type Count signifies that the action is repeated a certain number of times (e.g. do [something] 5 times). When the type has this value, field “times” holds the number of iterations. If the type has other values, the type models modifiers that do not express a specific number of iterations. Thus, when type is set to count, it holds the number of iterations, and otherwise, type is ignored. Table 38 provides some terms and phrases that can be modeled by the Iteration restriction.

[0172]

TABLE 38
Example Phrases Modeled by Iteration
Restriction.
	ENGLISH
	5 times
	never
	sometimes
	frequently
	seldom
	FRENCH
	5 fois
	jamais
	souvent
	rarement
	GERMAN
	5 Mal
	nie, niemals
	manchmal, ab und zu
	oft
	selten
	JAPANESE
	5
	SPANISH
	5 veces
	nunca
	algunas veces, de vez en cuandocon
	frecuencia, frecuantementeraramente

[0173] It will be understood by a worker skilled in the art that other Iteration restriction types exist in most languages. The Iteration restriction can be accessed using most languages.

[0174] A Location restriction models a physical or metaphorical location. Table 39 illustrates the syntax of the Location restriction.

[0175]

TABLE 39
Location Restriction.
	restriction Location<loc:= Entity>
	{
	}

Table 40 illustrates terms and/or phrases that can be modeled by the Location restriction.

[0176]

TABLE 40
Exemplary Terms/Phrases Modeled by
Location Restriction.
	ENGLISH
	at
	FRENCH
	à
	GERMAN
	in/bei +Dative
	Er ist in der Stadt.
	Er ist bei Hamburg.
	JAPANESE
	NP-

[0177] It will be understood by a worker skilled in the art that other Location restriction types exist in most languages. The Location restriction can be accessed using most languages.

[0178] A Means restriction models a means or device for accomplishing something for an Entity or a Frame. The syntax of the Means restriction is illustrated in Table 41.

[0179]

TABLE 41
Means Restriction.
	restriction Means<means := Entity>
	{
	}
	restriction Means<means := Frame>
	{
	}

[0180] It will be understood by a worker skilled in the art that other Means restriction types exist in most languages. The Means restriction can be accessed using most languages. Example terms/phrases that can be modeled using the Means restriction are shown in Table 42.

[0181]

TABLE 42
Example Terms/Phrases Modeled by Means
Restriction.
	ENGLISH
	with a knife
	employing a knife
	use a spreadsheet program
	by arriving early
	FRENCH
	PP[avec]
	GERMAN
	PP[mit]
	Er schneidet mit dem Messer
	benutzen, gebrauchen
	SUBCL[indem]
	Er gewinnt, indem er schnell rennt
	JAPANESE
	NP-
	NP-
	VP-

[0182] A Measure restriction models a weight or measure of an object for a Frame or Entity. Table 43 illustrates the syntax of the Measure restriction according to an embodiment of the present invention.

[0183]

TABLE 43
Measure Restriction.
	restriction Measure<measure := Entity>
	{
	}
	restriction Measure<measure := Frame>
	{
	}

[0184] It will be understood by a worker skilled in the art that other Measure restriction types exist in various languages. The Measure restriction can be accessed using most languages. Table 44 illustrates exemplary terms/phrases that can be modeled by the Measure restriction.

[0185]

TABLE 44
Example Terms/Phrases Modeled by Measure
Restriction.
	ENGLISH
	Weight: three pounds
	Money: $4, fifty yen
	Distance: 3 yards
	Time: all day
	FRENCH
	Weight: deux kilogrammes
	Money: un franc
	Distance: cinq kilometres
	Time: toute la journée
	GERMAN
	Weight: drei Kilo
	Money: 4DM.
	Distance: 3 Meter
	Time: den ganzen Tag

[0186] A Modifier restriction may be considered a “catchall” (a “garbage dump”) restriction in that it does not model a semantically coherent class of linguistic expressions. It instead captures the syntactical notion of “adjuncthood”. In general, the Modifier restriction may model an adjective phrase, a noun phrase, or an adverbial phrase with respect to an Entity, a Frame, or a Restriction. In one implementation, a modifier slot is simply set to a denoter object constructed from the head word of the syntactic phrase being modeled. However, this implementation is not necessarily required in order to utilize the LOM. Table 45 illustrates a syntax of the Modifier restriction according to an embodiment of the present invention.

[0187]

TABLE 45
Modifier Restriction.
	restriction Modifier<mod := Denoter>
	{
	}

[0188] In general, Modifier restrictions model certain classes of linguistic modifiers in any context. While any linguistic modifier can become a modifier, Modifier restriction is intended as the primary LOM representation of only a subset of linguistic modifiers. That subset includes most or all adjective phrases, most or all noun phrase modifiers and some adverbial phrases. Many adverbial phrases, time expressions being one major example, find their primary LOM expression in other, more specific restrictions.

[0189] The Modifier restriction is unusual in that its slot contains a denoter object, rather than an Entity, Frame or Restriction. The Denoter object string is the head word of the modifier. The reason for this arrangement is that, while linguistic modifiers are semantically one-place functors over their hosts (the constituents that they modify) and are therefore similar to frames, in practice they are almost exclusively used as restrictions. Additionally, linguistic modifiers are almost never in other contexts where frames might appear. Rather than require cumbersome frame-based restriction syntax (something along the lines of with MyLargeFrame<this>) and the definition of a frame type for each desired modifier class, it is sufficient to specify only the Denoter object for a modifier class and take as the semantic argument the implicit restriction argument (such as the host object the restriction attaches to).

[0190] Predicative adjectives in relative clauses are represented the same way as the corresponding attributive use of that same adjective. So, “a large file” and “a file that is large” both become Modifier<large>.

[0191] This treatment of adjectives may not be appropriate for some languages, such as for JAPANESE, which has adjectives that behave syntactically indistinguishably from verbs. While nouns are very similar cross-linguistically, nouns are mapped to SPL entities. While verbs are also similar cross-linguistically, verbs are mapped to SPL frames. Adjectives, then, are somewhere in between nouns and verbs, and adjectives are not similar cross-linguistically.

[0192] Languages can be considered to exist on a continuum. On one end of the continuum, adjectives are not really a separate lexical category from verbs, such as in the Korean language. In this instance, adjectives are just stative, intransitive verbs. The Japanese language is similar to Korean in this regard, with adjectives behaving syntactically like verbs (although they are different morphologically). The English language and those languages that derive from Latin roots (such as the Euro languages) treat adjectives as a different category from verbs. On the other end of the spectrum, languages, such as Arabic, treat adjectives as nouns of a certain class. Rather than a word for “red”, Arabic uses a noun meaning something like “a red one”, such that the phrase “the book is red” becomes “the book is a-red-one.”

[0193] In some embodiments, there may be a representation for predicative adjectives in matrix clauses. For example, the phrase “this file is personal” could be handled differently from “this file is text”.

[0194] Additionally, it will be understood by a worker skilled in the art that other Modifier restriction types exist in various languages. The Modifier restriction can be accessed using most languages.

[0195] A Named restriction provides access to the denoter object of the host entity. This allows (for example, MyAlias and DL_MyAlias to be normalized to a single DLEntity without requiring the author to code for two different restrictions. Table 46 illustrates the syntax of a Named restriction according to an embodiment of the present invention.

[0196]

TABLE 46
Named Restriction
	restriction Named<named := Denoter>
	{
	}
	restriction Named<named := NamedEntity>
	{
	}
	restriction Named<named := String>
	{
	}

In general, the Named restriction is set to the denoter object of the noun phrase name or the host entity. In some embodiments, the Named restriction may be used to provide some access to named entity attributes. In another embodiment, the Named restriction is merged into the Modifier restriction. In general, the Named restriction can present an already-present piece of information (such as the host entity's denoter object) as needed.

[0197] It will be understood by a worker skilled in the art that other named restriction types exist in various languages. The Named restriction can be accessed using most languages.

[0198] A Negation restriction models a semantic negation or logical NOT. Table 47 illustrates an example of syntax for the Negation restriction according to an embodiment of the present invention.

[0199]

TABLE 47
Negation Restriction.
	restriction Negation
	{
	}

In some embodiments, the Negation restriction may be presented as a separate restriction. In an alternative embodiment, the Negation restriction may be consumed either by a “with Negation” clause or by “!” (Not operator).

[0200] An Ordinal restriction models ordinal numeral and other modifiers (such as “previous”) that express some notion of position in a sequence. Table 48 illustrates a syntax for the Ordinal restriction and its enumeration according to an embodiment of the present invention.

[0201]

TABLE 48
Ordinal Restriction and Enumerations.
	restriction Ordinal
	{
	int	distance;
	ReferencePoint	refPoint;
	}
	enum ReferencePoint
	{
	First,
	Last,
	Current
	}

In general, a distance field may be set to the signed integer distance from the reference point. Alternatively, a reference point field (refpoint) called first must indicate a non-negative distance. A distance value of zero (0) models first, a value of one (1) models second, and so on. A reference point field of last must have a non-positive distance. A distance value of zero (0) models last, a value of minus one (−1) models next-to-last, and so on. A current reference point distance may hold any integer value. A distance value of zero (0) models “current” status, a value of one (1) models “next”, a value of minus one (−1) models “previous”, and so on.

[0202] Table 49 provides phrases that can be modeled by the Ordinal restriction.

[0203]

TABLE 49
Example Phrases Modeled by Ordinal
Restriction.
	ENGLISH
	first, 4th
	last, next to last, 3rd from the end
	previous, current, next, two back, two
	ahead
	FRENCH
	premier, 4e
	dernier
	GERMAN
	erst, 4te
	letzte/r/s, vorletzte/r/s
	nächste/r/s, zwei _, zwei weiter
	JAPANESE
	, 4
	,  2
	, , , 2 ,
	SPANISH
	primero, 4°
	last, next to last, 3rd from the end
	previo, _, proximo, dos _, dos mas

[0204] It will be understood by a worker skilled in the art that other Ordinal restriction types exist in various languages. The Ordinal restriction can be accessed using most languages.

[0205] A Possessed restriction models a property, attribute or possession, and serves as a complement to the Possessor restriction (described below) Table 50 illustrates the syntax associated with the Possessed restriction according to an embodiment of the present invention.

[0206]

TABLE 50
Possessed Restriction.
	Restriction Possessed<possessed := Entity>
	{
	}

[0207] In general, the Possessed restriction models a property, attribute or possession. For example, the phrases email with headers, schools with linguistics programs and the like can be modeled by the Possessed restriction. In some instances, the Possessed restriction may be referred to as “having” an attribute, property, or possession. Table 51 provides some exemplary terms and phrases that can be modeled using the Possessed restriction.

[0208]

TABLE 51
Example Terms/Phrases Modeled by Possessed
Restriction.
	ENGLISH
	with
	mail with “conference” in the subject
	line
	document with size greater than 1k
	of
	files of greater size
	GERMAN
	RELCL
	Mail, die “Treffen” in der
	Betreffzeile hat
	mit
	Mail mit Anhang

[0209] It will be understood by a worker skilled in the art that other Possessed restriction types exist in various languages. The Possessed restriction can be accessed using most languages.

[0210] A Possessor restriction complements the Possessed restriction. In general, the Possessor restriction models an entity's possessor, whether expressed by a full noun phrase or by a possessive pronoun. Table 52 illustrates the syntax of a Possessor restriction according to an embodiment of the present invention.

[0211]

TABLE 52
Possessor Restriction.
	restriction Possessor<possessor := Entity>
	{
	}

Table 53 provides exemplary terms/phrases that can be modeled by the Possessor restriction.

[0212]

TABLE 53
Example Terms/Phrases Modeled by Possessor
Restriction.
	ENGLISH
	my, your, her, his, its, their
	of mine, of yours, of hers, of his, of its,
	of theirs
	(wheel) of the car
	Kim's, the computer's
	some instances of PP[of]'s
	FRENCH
	mon, son, ta, sa, leur
	de moi, de toi, de lui, d'eux
	some instances of PP[de]'s
	GERMAN
	mein, dein, sein, ihr, Ihr
	some instances of PP[von]
	some instances of genitive case
	JAPANESE
	,  ,  ,
	some instances of NP-

It will be understood by a worker skilled in the art that other Possessor restriction types exist in various languages. The Possessor restriction can be accessed using most languages.

[0213] Another restriction that is modeled in the LOM is the Purpose restriction. The Purpose restriction models an anticipated outcome that is associated to a Frame. Table 54 illustrates some exemplary phrases/terms that can be modeled by the Purpose restriction.

[0214]

TABLE 54
Terms/Phrases Modeled by Purpose
Restriction.
	ENGLISH
	for, in order to
	FRENCH
	pour, afin de; de sorte que; de sorte à; de
	façon à
	GERMAN
	um...zu
	so dass
	SPANISH
	para, para que, con objeto de, con el fin
	de

[0215] A Reason restriction models a rational motive for a belief or action that is associated with a frame or an entity. In one embodiment, the Reason and the purpose restrictions may overlap in scope. Table 55 illustrates exemplary terms/phrases that may be modeled by the Reason restriction.

[0216]

TABLE 55
Terms/Phrases Modeled by the Reason
Restriction.
	ENGLISH
	because, in order to
	FRENCH
	parce que ; à cause de ; en raison de
	GERMAN
	fuer
	weil
	wegen
	SPANISH
	por, porque, a causa de.

Both the Reason restriction and the Purpose restriction may be modeled in any number of languages. The exemplary terms/phrases listed above are not entended to serve as an exhaustive list, but rather to illustrate terms that might be modeled by the restrictions.

[0217] A SortOrder restriction models modifiers that describe the styles and/or methods of data ordering. Table 56 illustrates a syntax for the SortOrder restriction and its associated enumeration OrderType.

[0218]

TABLE 56
SortOrder Restriction.
	restriction SortOrder
	{
	OrderType type;
	OrderCriteria criteria;
	}
	enum OrderType
	{
	Default,
	Reverse,
	Increasing,
	Decreasing
	}
	enum OrderCriteria
	{
	Default
	Alphabetic,
	Numeric,
	GoJuuOn,
	Iroha
	}

In general, the field type may be default, reverse, alphabetic, numeric, increasing, decreasing, and so on. A default type models in default order, in any order, and so on. Reverse type models in reverse order (backwards). Alphabetic type models alphabetically (in alphabetical order). Numeric type models numerically (in numeric order). Increasing type models in increasing order. Decreasing type models in decreasing order.

[0219] Depending on the implementation, the SortOrder restriction may be put on entities for things like “alphabetical list”. Additionally, verbs such as “alphabetize”, “categorize”, “group”, “classify” and “index” may be modeled by the SortOrder restriction. In certain instances, it may be desirable to include two fields for modeling phrases like “reverse alphabetical order”, “decreasing alphabetical order”, and the like. Moreover, there may be different sort orders common to two different languages. While the enumerations listed in Table 56 are common to the English language, Japanese may have additional sort ordering that is common to the language. Table 57 illustrates exemplary phrases/terms that can be modeled by the SortOrder restriction.

[0220]

TABLE 57
Terms/Phrases Modeled by the SortOrder
Restriction.
	ENGLISH
	in default order, in any order
	in reverse order, backwards
	alphabetically, in alphabetic order
	numerically, in numeric order
	in increasing order
	in decreasing order
	FRENCH
	dans l'ordre par défaut; dans n'importe
	quel ordre
	par ordre inverse; en ordre inverse; dans
	l'ordre inverse
	alphabétiquement, par ordre alphabétique
	numériquement, par ordre numérique
	par ordre croissant ; par ordre ascendant;
	par ordre décroissant ; par ordre
	descendant
	GERMAN  [Babel]
	im Rückstellung Auftrag, in irgendeinem
	Auftrag
	im Rückauftrag, rückwärts
	in der alphabetischen Reihenfolge,
	alphabetisch
	im numerischen Auftrag, numerisch
	in zunehmendem Auftrag
	in abnehmender Reihenfolge
	JAPANESE
	,
	default-no-order-de,  favorite-
	order-ni
	,      or
	reverse-no-order-de  reverse-ni
	opposite-ni
	or
	alphabet-order-ni    ABC-order-ni
	number-order-ni
	or
	small-number-order-ni  low-number-
	order-ni
	or
	large-number-order-ni  high-number-
	order-ni
	SPANISH
	ordenados por defecto, en el orden por
	defecto, en cualquier orden
	en orden inverso, al revés
	en orden alfabético, alfabéticamente
	en orden numérico, numéricamente
	en orden ascend(i)ente, de menor a mayor
	en orden descend(i)ente, de mayor a menor

[0221] A Source restriction models a source or origin of an object. The syntax for the Source restriction is shown in Table 58.

[0222]

TABLE 58
Source Restriction.
	restriction Source<src := Entity>
	{
	}

In general, it will be understood by a worker skilled in the art that various Source restriction types may exist for multiple languages.

[0223] A StructureCriteria restriction models a notion, with respect to Frames, of operating over a set of objects in a structured manner. The StructureCriteria restriction models the criterion or criteria by which that operation proceeds. The syntax for the StructureCriteria restriction is shown in Table 59.

[0224]

TABLE 59
StructureCriteria Restriction.
	restriction StructureCriteria<criteria :=Entity>
	{
	}

In some implementations of the LOM, it may be desirable to include a restriction called “increment” for modeling phrases such as “in pairs”, “5 at a time” and so on. These kinds of phrases contain nicely-normalizable numeric criteria that, depending on the implementation, may be important enough to include some specialized way of modeling them. Table 60 illustrates some terms and phrases that may be modeled by the StructureCriteria restriction.

[0225]

TABLE 60
Terms/Phrases Modeled by Structure
Criteria Restriction.
	ENGLISH
	sort by subject, list by date
	display in rows
	transmit in 1KB blocks
	get my email one at a time
	GERMAN
	sortieren nach Thema
	anzeigen
	senden/schicken

[0226] The “Substitution” restriction models a participant in a semantic event where one term substitutes for another. One possible example, in. French, is where a substitutes for pour as an adjunctive. An adjunctive is a type of adverbial indicating the circumstances of the action. Similarly, in Spanish, por is used as an adjunct, and para may be used with selected verbs.

[0227] Time may be treated as a restriction. In general, the Time restriction models time modifiers involving references to specific units of time or points in time that can be expressed as entities. For example, “after July 23rd” and “after Thanksgiving” can be modeled by Time restrictions. However, in some embodiments, phrases such as “after my computer boots up” are not modeled by the Time restriction. Similarly, ranges of time, such as “from 3:00 to 6:00” and “between morning and evening” can be modeled by the Time restriction. However, “while the defrag utility is running” may not be modeled by the Time restriction. Time expressions involving embedded clausal content are handled in the Conditional restriction. TABLE 61 illustrates a syntax and implementation of time as a restriction within the LOM.

[0228]

TABLE 61
Time Restriction.
	restriction Time
	{
	BaseTime	startTime;
	BaseTime	endTime;
	BaseTime	pointorSpan;
	Duration	duration;
	TimeLength recurrence;
	}
	abstract class BaseTime
	{
	}
	abstract class AbsoluteTime : BaseTime
	{
	}
	class NowAbsoluteTime : AbsoluteTime
	{
	}
	class Analyzed AbsoluteTime : AbsoluteTime
	{
	int	second;
	int	minute;
	int	hour;
	int	date;
	int	week;
	Weekday	weekday;
	Month	month;
	Int	year;
	Era	era;
	AmPm	ampm;
	}
	enum Weekday
	{
	Unspecified,
	Monday,
	Tuesday,
	Wednesday,
	Thursday,
	Friday,
	Saturday,
	Sunday
	}
	enum Month
	{
	Unspecified,
	January,
	February,
	March,
	April,
	May,
	June,
	July,
	August,
	September,
	October,
	November,
	December
	}
	enum Era
	{
	Unspecified,
	BCE,
	CE,
	Heisei,
	Showa,
	Taisho,
	Meiji
	}
	enum AmPm
	{
	Unspecified,
	Am,
	Pm,
	TwentyFourHour
	}
	class UnanalyzedAbsoluteTime : AbsoluteTime
	{
	Denoter timeExpression;
	}
	abstract class RelativeTime : BaseTime
	{
	BaseTime relativeTo;
	}
	class offsetRelativeTime : RelativeTime
	{
	Offset offset;
	}
	class Offset
	{
	Direction	direction;
	TimeLength	timeLength;
	Granularity	granularity;
	}
	enum Direction
	{
	Unspecified,
	Forwards,
	Backwards,
	}
	enum Granularity
	{
	None,
	Seconds,
	Minutes,
	Hours,
	Days,
	Weeks,
	Months,
	Years,
	Decades,
	Centuries,
	Millenia
	}
	class TimeLength
	{
	float	amount;
	TimeUnit	unit;
	Denoter	otherUnit;
	}
	enum TimeUnit
	{
	Other,
	Minutes,
	Hours,
	Days,
	Weeks,
	Months,
	Years,
	Decades,
	Centuries,
	Millenia,
	Mondays,
	Tuesdays,
	Wednesdays,
	Thursdays,
	Fridays,
	Saturdays,
	Sundays,
	Januaries,
	Februaries,
	Marches,
	Aprils,
	Mays,
	Junes,
	Julys,
	Augusts,
	Septembers,
	Octobers,
	Novembers,
	Decembers
	}
	class SubsetRelativeTime : RelativeTime
	{
	AbsoluteTime subset;
	}
	class Duration
	{
	TimeLength	timeLength;
	TimeLengthQualifier	qualifier;
	}
	enum TimeLengthQualifier
	{
	None,
	MoreThan,
	LessThan,
	AtLeast,
	AtMost,
	Precisely
	}

[0229] The Time restriction makes use of one or more fields and a large number of auxiliary data types as needed. Fields may include start time, end time, “point or span”, duration, and recurrence. The start time field is set to a base time derived object expressing the starting point of a time span, such as “from 5:00” or “after tomorrow”. If the start time field is null, then the time modifier modeled contains no overt expression of a starting point.

[0230] An end time field is set to a base time derived object expressing the ending point of a time span, such as “to 6:00” or “until Friday”. If the end time field is null, then the time modifier modeled contains no overt expression of an ending point.

[0231] A point or span field is set to a base time derived object expressing a solitary time point or span expressed in a single phrase, as opposed to time spans expressed by overtly naming starting and ending points. For example, with respect to “tomorrow”, the idea is that whether “tomorrow” is a single point on a time line or a 24-hour span of time depends on the context and the viewer's point of view. The LOM makes no attempt to disambiguate the term. If the point or span field is null, then the time modifier modeled contains no overt expression of a solitary time point or span.

[0232] A duration field may be set to a duration object expressing a length of a span of time without expressing the particular starting and ending points. For example, the phrase “for two hours” can be modeled by the duration field. If null, then the time modifier modeled contains no overt expression of duration. The duration inherent in a time span such as “from 4 pm to 6 pm” is not expressed as a duration object. In this case, there would be non-null values for start time and end time, but duration would be null.

[0233] A recurrence field is set to a time length object expressing the interval between occurrences of a recurring event. For example, phrases, such as “daily”, “weekly”, “monthly”, “the first Monday of every month” and so on, can be expressed as a time length object. If null, then the time modifier modeled is not interpreted as recurring.

[0234] In general, the Time restriction makes use of a large number of auxiliary data types. For example, BaseTime chains are objects derived from BaseTime, consisting of zero or more objects derived from RelativeTime and exactly one “root” object derived from AbsoluteTime. They are referred to as “chains” because each RelativeTime-derived object holds a reference to the next object in the chain, while the root AbsoluteTime-derived object holds no such reference.

[0235] AbsoluteTime derived types, such as NowAbsoluteTime, do not hold the reference to other objects in the chain. The NowAbsoluteTime derived type, for example represents the unanalyzable “now” of an utterance's speech time. The LOM does not attempt to resolve “now” into, for instance, 3:42:27 pm on Oct. 24, 2002.

[0236] AnalyzedAbsoluteTime is an AbsoluteTime derived-type that represents time point or spans that can be analyzed in terms of seconds, hours, days, years, and so on. For example, AnalyzedAbsoluteTime can be used to represent the time point “now” as 3:45, 10 May 2003, Wednesday at 9:30 am.

[0237] UnanalyzedAbsoluteTime is an AbsoluteTime derived-type that represents expressions that known to be time points, but which cannot be analyzed in terms of atomic time units. For example, holidays, seasons of the year, and abstract temporal concepts tend to fall into this category. For example, “Thanksgiving”, “Election Day”, “my birthday”, “summer”, and “this evening” are all phrases that are modeled as UnanalyzedAbsoluteTime.

[0238] There exist two RelativeTime-derived types: OffsetRelativeTime and SubsetRelativeTime. OffsetRelativeTime represents a positive or negative offset of a particular length of time from the referenced BaseTime-derived object. For example, the phrase “two days ago” is modeled as “[2 days back] OFFSET FROM [now]”.

[0239] SubsetRelativeTime is a RelativeTime-derived type that represents a time point or span interpreted as being a subset of the enclosing time span expressed by the reference BaseTime-derived object. For example, expressions of time dimensions such as “at 5:00 on my birthday” can be modeled as equivalent to “[hour:5 min:0] SUBSET OF [“my birthday”]”. It is important to note that a time reference such as “5:00 on Wednesday” can be captured by a single AnalyzedAbsoluteTime object, because the phrase can be decomposed into time units.

[0240] In some embodiments, it may be desirable to have more than one pair of StartTime and EndTime fields. For example, in order to capture expressions such as “from Monday to Friday from 4:00 to 5:00”, two pairs of start and end time fields may be desirable in order to capture both ranges. In fact, for the above-expression, it may be desirable to have Time entities. Additionally, the parallels between the following expressions suggest that Time entities might be desirable.

• • [0241] Move the meeting [from 4:00 to 5:00].
  • [0242] Move the file [from Folder1]_Source [to Folder2]_Goal.
    Additionally, EndTime should be distinguished from ordinary Goals, since not all structures that take Sources and Goals permit StartTime and EndTime to function as such. For example, a structure adapted to model the expression “Run a meeting [from 4:00 to 5:00]” may not permit StartTime and EndTime to function properly.

[0243] Another restriction is the Topic Restriction. With respect to Entity objects, the Topic restriction models arguments or modifiers that express what an entity is about or what it concerns or pertains to. A Topic restriction associated with a Frame models verbal arguments that express the subject or topic of the event. In general, the Topic restriction has a Slot set to the Entity or Frame that models the topic or subject. Alternatively, the Slot can take a string. Table 62 illustrates the syntax of a Topic restriction according to an embodiment of the present invention.

[0244]

TABLE 62
Topic Restriction.
	restriction Topic<topic := Entity>
	{
	}
	restriction Topic<topic := Frame>
	{
	}

[0245] In some instances, it may be desirable to label the Topic restriction with a different name. Specifically, given the severe overloading (at least within the field of Linguistics) of the term “topic”, it may be desirable to use other labels for this restriction. Some alternative labels might include, for example, “Concerning”, “Regarding”, “About”, “Subject”, “Theme”, and so on. Table 63 provides some exemplary Terms/Phrases that can be modeled by the Topic restriction according to an embodiment of the present invention.

[0246]

TABLE 63
Example Terms/Phrases Modeled by Topic
Restriction.
	ENGLISH
	about, on
	concerning ..., regarding ...
	remind Sandy that Kim is coming tomorrow
	GERMAN
	über
	Zeige die Mail über den Hausbau.
	[bezüglich/bezgl.] +Genetive case
	Zeige Mail bzgl. des Hausbaus.
	JAPANESE
	NP-      NP
	NP-     VP

[0247] A Quantifier restriction models noun phrase quantifiers and partitive expressions such as two-thirds of. In general, the Quantifier restriction may include type or percentage fields. The type field may be a percentage, which is stored as a floating-point number, typically (but not necessarily) between zero and one. For example, the percentage type models one half of, 75% of, 200% increase, and the like. The type field may also model quantifiers that do not correspond to exact percentages. The terms “all” and “none” are enumerated as different “privileged” values that do not fall into this “other” type. The percentage field holds the percentage corresponding to the meaning of the quantifier if the type has a value of Percentage. Otherwise, the percentage field is ignored. Table 64 illustrates the syntax for the Quantifier restriction and its associated enumerations.

[0248]

TABLE 64
Quantifier Restriction.
	restriction Quantifier
	{
	QuantifierType type;
	Float   percentage;
	}
	enum QuantifierType
	{
	All,
	None,
	Some,
	Most,
	Many,
	Few,
	Percentage
	}

In some implementations, it may be desirable to treat negations differently. Rather than enumerate terms such as “none”, it may be desirable to handle negations as noun phrases. Table 65 illustrates some exemplary terms/phrases that can be modeled by the Quantifier restriction.

[0249]

TABLE 65
Terms/Phrases Modeled by Quantifier
Restriction.
	ENGLISH
	All: all ((of) the), every, each (of the)
	None: no, none (of the)
	Some: some (of the)
	Most: most (of the), the majority of
	Many: many (of the)
	Few: few (of the), not many (of the)
	Percentage: a half of, ⅓ of, 40% of
	GERMAN
	All: alle (Gen), jede/r/s
	None: keine/r/s (Gen)
	Some: manche/r/s (Gen)
	Most: die meisten (Gen), der Groβteil (Gen)
	Many: viele (Gen)
	Few: wenige (Gen)
	Percentage: die Hälfte von(Gen), ⅓ von/ (Gen),
	80% von/(Gen)

It will be understood by workers skilled in the art that the above-discussions with respect to exemplary terms and phrases is intended to illustrate domain and language independence, rather than to illustrate any particular limitation with respect to linguistic modeling. In general, the LOM can model any number of languages.
D4. Classes of Frames: Lexical Semantic Structure

[0250] The following discussion relates to one aspect of a possible implementation of an LOM object producer (analysis engine), which is referred to as a Lexical Semantic Structure (LSS). This particular aspect was developed in conjunction with the LOM, but numerous other implementations may be utilized to produce LOM objects. The LSS was also used in the design process for the types of the LOM.

[0251] Generally, the LSS identifies groups of frames and entities that share syntactic and semantic frames, which differ from the default patterns in one of the supported languages. In general, Lexical Semantics is a subfield of linguistics that deals mainly with word meaning. Lexical semantic structure (LSS) theory relates to the relationship of word meaning to sentence meaning and syntax. Additionally, LSS theory addresses the differences and similarities in lexical semantic structure between different languages.

[0252] In general, Frames have two default patterns: a transitive default pattern and an intransitive default pattern. The transitive default pattern links the Who slot to the subject position and the What slot to object position. By contrast, the intransitive default pattern lacks the What slot and object position. Both are illustrated in the following examples headed by a verb type.

• • [0253] [User]_Who types [email address]_What.
  • [0254] [User]_Who types.
    Frames can vary from the default in both linking (how the slots of the frame are populated by the grammar) and argument structure (number of slots). For example, in one non-default linking type, the Unaccusative, classes of verbs have different linking patterns for the intransitive pattern, as seen in the frames below, headed by the verb increase.
  • [0255] [Users]_Who generally increase [the font size]_what. of headers.
  • [0256] [The font size]_what generally increases in headers.
    In this case, the subject of the intransitive is the same as the object of the transitive, and is linked to the What slot. In Linguistics, these Unaccusative non-default linking types are sometimes referred to as “ergative” verbs, after their case-marking patterns in some languages. Such verbs generate an additional non-default linking pattern in the intransitive, in addition to the default linking pattern.

[0257] In another non-default linking type, ObliqueAsDefault, classes of verbs express a Who or What argument as an oblique argument. For example, reciprocals in ENGLISH express an additional Who or What participant as the object of an Accompaniment restriction.

• • [0258] Additional Who: I chatted with John˜John and I chatted.
  • [0259] Additional What: I merged file A with File B˜I merged File A and B.
    Other languages express reciprocals as an additional pronominal argument, meaning an argument that relates to a pronoun or that identifies or specifies an object without describing the object. These are also treated under the Accompaniment restriction.

[0260] Many verbs have syntactically oblique arguments (marked by idiosyncratic prepositions) that seem to associate semantically with the What slot. That is, if the verb is intransitive, and the prepositional phrase does not fall semantically into one of the restriction categories, and the phrase can be paraphrased (or translated into another language) as a direct object, it may be treated as linking to the What slot. Several examples are provided to illustrate phrases that trigger the Oblique as default slot in Table 66.

[0261]

TABLE 66
ObliqueasDefault.
	Juan confía en Pedro ->‘John trusts Peter’
	I'm waiting for MSN8 -> I'm awaiting MSN8.
	Look for files on the internet -> Find files on
	the internet.

These may be associated with semantically coherent classes (hope for, watch for, wait for), or they may be individually marked on a set of verbs that take a certain preposition in this way, as a case-marker of sorts (e.g. find and look for).

[0262] Classes of verbs can vary from the default by having slots in addition to (or instead of) Who and What in the frame. Moreover, some classes of verbs link syntactic subjects or objects to restrictions in the LOM rather than to the Who or What slots. In other words, either or both the default slots may be replaced by a restriction.

[0263] SubjectAsRestriction patterns link subjects to a restriction rather than to the. What slot. The verb “receive”, for example, takes a Goal as subject.

• • [0264] [The website]_Goal received the data.
  • [0265] [The garden] swarmed with bees.˜Bees swarmed in the garden.

[0266] Similarly, the ObjectAsRestriction pattern projects frame in which the syntactic object is a Goal rather than a What. For example, the verb “enter” maps t a frame in which the syntactic object is a Goal or location, rather than a what.

• • [0267] Enter [the chat room]_Goal (cf. Enter in(to) the chat room, Go in the chat room)

[0268] Frames can also vary from the default in semantically entailing one or more additional restrictions as obliques. AdditionalRestriction patterns link additional restrictions as oblique arguments or clausal complements, in addition to the default slots. For example, change of state verbs can take an additional Goal (as with the verb “reset”), or can take both a Source and a Goal (such as with the verb “change”), as shown below.

• • [0269] Reset [the default font]_what [to Times New Roman]_Goal.
  • [0270] Change [the font]_What [from Arial]_Source [to Times New Roman]_Goal.

[0271] Additionally, Frames can vary from the default in various ways, such as by combining one or more of the above non-default linking types (Unaccusative, SlotAsRestriction [subject or object], and AdditionalRestriction). Moreover, verbs can project multiple frames, which can be construed as taking different senses. The default frame holds for one sense of “enter”, and SlotAsRestriction for another. The verb “enter” may be context sensitive.

• • [0272] Enter [the data]_What (into the form).
  • [0273] Enter [the chat room]_Goal
    The keyword “Keep” takes the default and three non-default frames, having different senses. For example,
  • [0274] Default: Keep [the file]_What
  • [0275] AdditionalRestriction (Location): Keep [the file]_What [on the desktop]_Location.
  • [0276] AdditionalRestriction (Goal): Keep [Bill Gates]_What [from emailing me]_Source
  • [0277] Unaccusative: The data won't keep.
    In general, it is desirable to have Lexical Semantic Structure frames across all supported languages, for verbs that differ from the default in at least one language. For the purpose of this disclosure, it is assumed that this is true for both transitive and intransitive verbs.

[0278] For some verbs (such as “expand”, “increase”, and so on), only the unaccusative pattern may be valid for the intransitive. For other verbs, unaccusative pattern linking is an additional option.

[0279] Table 67 illustrates some exemplary phrases/terms that can be modeled by LSS Frames with additional restrictions. In each example, the restriction replaces a default argument, or adds an argument to a frame. In principle, each restriction could appear in the subject position, in the object position, or as an additional oblique argument. A few restrictions add a participant to Who and What slots, as noted below. Related Noun Phrase (NP) frames are also given.

[0280]

TABLE 67
Accompaniment Modeled by LSS Frames with
Additional Restrictions
	Accompaniment
	In subject position
	Meet: My daughter and I met
	Chat: My friend and I chatted.
	In object position
	Accompany: My daughter accompanied me
	to Minneapolis.

[0281] In English, the additional restriction is typically headed by the pronoun “with” or perhaps “against”. A variety of verb subclasses select this pronoun or pronoun phrase on the relevant meaning. A sample is given below in Table 68.

[0282]

TABLE 68
LSS Frames with Additional Restrictions
	Abscond: The Enron executives absconded with the
	money.( )
	Accommodate: indulge
	Accredit: accredit, credit
	Ache: ache, burn, itch
	Arrange

[0283] In English, the Accompaniment restrictions can also add participants to the Who and What slots. Although this is true for frames in which this restriction is a modifier, it is especially common with “reciprocal” verbs. Table 69 provides some examples of Oblique as a default slot.

[0284]

TABLE 69
Oblique as a Default Slot.
	Who
	Subject reciprocals
	Chat: I IMed with Mary ~ Mary and I IMed;
	chat, discuss, talk, visit
	Agree
	Alternate
	Unaccusatives: The file merged (together)
	with the data ~ The file and the data
	merged (together).
	What
	Object reciprocals:
	Merge: I merged the files with the data, I
	merged the data and the files
	Acquaint: I familiarized them with the
	topic; acquaint

[0285] In English, the additional restriction is headed by the PP “for” with respect to Allocation. A variety of verb subclasses take this PP on the relevant meaning. A sample is given below.

• • [0286] Adapt: Adapt the movie for the stage.
  • [0287] Allocate: Allocate funds for linguistics; allocate, appropriate,
  • [0288] Appropriate: Appropriate funds for increased wages
  • [0289] Assign: Assign a day for the performance
  • [0290] Nominate: Nominate candidates for congress
  • [0291] Transcribe: Transcribe the music for trumpet
  • [0292] Train: Train for a marathon

[0293] A secondary predicate with respect to the AsBeing restriction can be utilized as an additional restriction. Some exemplary phrases are provided in Table 70 below.

[0294]

TABLE 70
Secondary Predicate of the AsBeing
Restriction.
	Noun Phrase
	Make me administrator
	Adjunctive Phrase
	mark messages low-priority
	judge the data correct
	mark that completed
	mark low priority
	judge the data correct
	Pronoun Phrase (as) variant
	mark task one as done
	Mark messages as follow-up
	mark that as completed
	mark as low priority
	judge the data as correct
	Additional restriction
	Show my status as busy
	use as text file
	save as file.doc
	Log in as Administrator
	put this message as message number two

[0295] Additional restrictions with respect to the Beneficiary restriction are shown in Table 71 below.

[0296]

TABLE 71
Beneficiary with Additional Restrictions.
	In object position
	Benefit: Relaxed stock option laws
	benefited Enron; benefit, gain, profit
	Unaccusative: Enron benefited from relaxed
	stock option laws
	In indirect object position
	Benefit: Relaxed stock option laws
	benefited Enron; benefit, gain, profit
	Unaccusative: Enron benefited from relaxed
	stock option laws
	Additional restriction
	PP-for and Indirect Object
	Build: arrange, assemble, bake
	Create: design, dig, mint
	Prepare: bake, blend, boil, clean, clear,
	cook, fix, fry...
	Performance: dance, draw, ding, play,
	recite...
	Get: book, buy, call, cash, catch

[0297] Some of the restriction types may be non-applicable for verb frames. However, the additional restrictions may still be invoked, such as where a prepositional phrases introduces a comparison set.

[0298] Direction restrictions may require additional restrictions such as with the phrase “move the cursor up (the page)”. Additionally, where the directional element is conflated in the verb itself (such as “the stocks rose/fell/advanced/retreated” or “rotate the picture”), additional restrictions may be required.

[0299] An LSS with an additional restriction can be understood from the following phrases, with the example restriction contained in the subject position.

• • [0300] This document exemplifies table construction Sample code illustrates possible applications.

[0301] The extent restriction typically falls within the object position or the additional restriction position. It is possible that all manner of motion type verbs may take an Extent object (e.g. “walk the mall”, “crawl the web”, “run the marathon” and so on). Example phrases that can be modeled by the Extent restriction are shown in Table 72.

[0302]

TABLE 72
Examples of Phrases Modeled by Extent
Restriction.
	In object position
	The crawler traverses the web.
	The data in this spreadsheet spans several
	builds.
	Additional restriction
	I want a border around this text.
	Maintain a uniform appearance throughout
	the web site.
	Run through the spec before the review.

[0303] A Goal restriction may require additional restrictions, particularly with respect to changing between classes or states. The scope of prepositional phrases that behave as Goals idiosyncratically with some verbs may vary according to implementation. Examples of a prepositional phrase that behave idiosyncratically as a Goal are “save as file.txt” (“save to file.txt”) and “reschedule for 5:00” (“reschedule to 5:00”).

[0304] Some verbs may need to take idiosyncratic goals, either in Bitrecs (if the Goal behavior is due to a single verb) or in LSS classes (if a class of items takes goals idiosyncratically). An additional goal may simply be added, and patterns can be pulled out from the lexicon into classes to address them as they are discovered.

[0305] The additional restrictions associated with location can be modeled as illustrated in Table 73 below.

[0306]

TABLE 73
Location.
	Keep, Stand, CausedGoalOfMotion
	In subject position
	Locative alternation (Levin 2.3): The
	garden swarmed with bees (cf. Bees swarmed
	in the garden)
	In object position
	Search: Canvass the neighborhood, Search
	the web
	Additional restriction
	Transitive:
	Keep: Keep the file on the desktop
	(hold, keep, locate, store)
	Get: Find a book on Amazon.com
	Intransitive
	Stay: Stand here, Stay home

[0307] The Means restriction may also be modeled with additional restrictions as shown in Table 74.

[0308]

TABLE 74
Means.
	Instrument Subject: The knife cut the cake
	Additional restriction
	Adorn: adorn, festoon, decorate
	Adulterate: adulterate, alloy, pollute
	Anoint
	Afflict
	Aid: aid, assist, help
	Analogize
	Anoint
	Answer
	Arm
	Assail: attack,

[0309] The SortOrder restriction may be modeled by additional restrictions as shown in Table 75.

[0310]

TABLE 75
Sort Order.
	ENGLISH
	Arrange alphabetically
	Additional restriction
	Arrange: sort alphabetically,
	FRENCH
	par ordre alphabétique inverse
	du plus petit au plus grand [literally:
	from the smallest to the biggest]
	du plus grand au plus petit [literally:
	from the biggest to the smallest]

[0311] Similarly, the structure criteria restriction may be modeled by additional restrictions as shown in Table 76.

[0312]

TABLE 76
StructureCriteria
	ENGLISH
	Arrange by name (cf. SortOrder above), in
	date order
	FRENCH
	{catégoriser classer classifier filtrer
	grouper indexer ordonner regrouper
	réarranger réindexer trier}
	Classe les messages {par ordre
	alphabétique, alphabétiquement}
	‘Sort the messages {in alphabetical order,
	alphabetically}’
	Regroupe mon courrier par date
	‘Group/cluster my mail by date
	Trie les fichiers en fonction de la taille
	‘Sort the files by size/as a function of
	the size’
	Indexe la table sur le nom
	‘Index the table on the name’

[0313] In general, classes that take a Time argument could be treated as classes that take a Measure restriction of type Time, although they can have the full time expression realized. For example, the following phrase can be modeled as a class that takes a time argument or a measure restriction of type Time: “I spent at least an hour from 9 to 5 every day for weeks looking for a piano.”

[0314] Table 77 illustrates some exemplary Topic phrases that may be modeled with additional restrictions.

[0315]

TABLE 77
Topic.
	Spact: talk about X, talk X, remind X that
	Y, book on Martin Luther
	In subject position
	Her finances don't concern you; concern
	In object position
	Discuss: The article addresses adolescents
	in the 20th century; address, cover, discuss
	Additional restriction
	PP[{about, concerning, on, regarding}]
	takes either NP objects (about cats) or
	clausal objects (about John coming to
	Seattle)
	PRPRTCL
	The object of address could also be the
	addressee, rather than the topic.

D5. Classes of Entities

[0316] This section provides a place to collect data on the types of entities supported as SPL libraries, such as Person Entities, Place Entities, and LSS Entities. Additionally, the SPL libraries may include classes of noun phrases (LSS entities) corresponding to each LSS frame class, particularly those that take additional restrictions.

[0317] The SPL libraries may also include Restriction classes. For each restriction, there is a (small) set of noun phrases that could be used to name the restriction. In SPL, these can be identified in a small set of structures as signaling the presence of the restriction slot filler. For example, when topic is the subject or object or the copula, the Topic restriction slot filler (in bold) is in the complementary position.

• • [0318] Find discussions where the economy is the topic.
  • [0319] Find discussions where the topic is the economy.
    Similarly, when topic fills the AsBeing slot, the entity to which it attaches fills the Topic slot.
  • [0320] Find discussions that have the economy as a topic.
    These structures should be normalized along with those identified as Topic restrictions.
  • [0321] Find discussions about/on/concerning/regarding the economy.
    Synonyms like theme, matter, subject, issue, focus, and area could also be a TopicEntity. Moreover, developers can add to the entity class topic words that are more specific to their scenario, such as “subject in an email application.”

[0322] E. Semantic Programming Language (SPL)

E1. Architecture.

[0323] SPL is a specialized programming language and with an accompanying runtime platform that allows application developers to build rich, natural language (NL) enabled, command and control (C&C) functionality for their application. (See Appendix I for a discussion on command and control scenarios that SPL can enable and the kind of commands that can be enabled, for example, for Outlook.)

[0324] SPL is an authoring solution to facilitate the derivation of meaning from utterances and to facilitate action based on that meaning. SPL is designed to scale to complex utterances without the developer having to bear the burden of that scalability. It is SPL's goal to facilitate authorship for both speech and text input without adding a lot of extra burden on the developer. Specifically, it is desirable to provide a NL authoring tool that allows developers with little or no knowledge of linguistic/semantic analysis to develop NL applications. In general, the SPL is designed to minimize differences between authoring for speech input and authoring for text input. However, due to speech recognition problems, some differences will likely have to be surfaced to the developer.

[0325] While the NL application can be written to interface with the analysis engines according to the LOM without the SPL, such programming is difficult, requires greater knowledge of linguistics by the developer, and more housekeeping with respect to lexical structures. In the end, the SPL facilitates development by abstracting specific elements so the developer can focus on the application's functionality, rather than the analysis component.

[0326] This is the whole point behind specialized programming languages, which free the developer from having to do the housekeeping and plumbing so he/she can concentrate on the task at hand (in this case, that's NL enabling applications). SPL allows the developer to express the fundamentals of the programming space in a natural and intuitive way.

[0327] In general, the semantics of natural language are complex and inherently ambiguous. Humans employ a great deal of world knowledge and context to understand and disambiguate meaning. In fact, humans do this understanding and disambiguation so naturally that we are often not consciously aware of the process.

[0328] For an application to be able to act on the meaning of an utterance, it not only has to decide what the semantics of an utterance mean to the application, but it must also have the authority to disambiguate meaning according to its own knowledge and context. Therefore, SPL provides the developer with the ability to reason about the application domain and to have that reasoning affect the semantic analysis in a deep and meaningful way. This deep integration with application-specific reasoning is intrinsically built into the SPL.

[0329] At a high level, in one embodiment, SPL's approach is to have the developer author against only the semantics of an utterance, not the syntax. Back door ways to access the syntax may be provided in some implementations. This is achieved through the LOM (discussed above in Section D). Briefly, the LOM models the semantics of an utterance (what is said) in a domain independent way. In many ways, the SPL programming model embodies this semantic model.

[0330] Through the resolution of an utterance against a SPL program, SPL builds the strongly typed, domain-dependent model of what is said that is bound to entities in the application. It is also worthy to note that, because the semantics are separated from the syntax, multilingual support is much easier to achieve.

[0331] SPL consists of two main pieces. The first is a language that is strongly-typed, procedural, event-driven, and object-oriented. In one embodiment, the SPL is based on C# (an object-oriented and type-safe programming language for building enterprise-scale applications) very familiar to mainstream developers today. In an alternative embodiment, the SPL is written entirely in C# through the use of attributes. In designing SPL, it was important that SPL not be a new approach to programming. Developers' existing knowledge and experience are leveraged, not invalidated. The second piece is a runtime that builds the domain-dependent model of what was said, in accordance with SPL's language semantics.

[0332] SPL enables developers to bind semantic meaning of an utterance with an existing application interface or object model, without impacting the existing application. While SPL does allow developers to write code that reasons about domain knowledge in place, the developer is also free to write that code in any programming language, including any Microsoft® .NET® programming language since SPL compiles to the .Net Common Language Runtime.

[0333] SPL's basic constructs are entities (nouns), frames (verbs), restrictions (relationships between entities), commands (application task entry points), NamedEntities and Denoters. These are the main first-class types of SPL. The language is command-centric by design, since it is designed for Natural Language-enabling Command and Control (C&C) functionality in applications.

[0334] Before discussing the SPL framework in detail, a simple SPL example is detailed in order to provide a mental picture for understanding the rest of the disclosure in context. Table 78 illustrates the SPL code that handles the “send email to Bob” command scenario. This command scenario will be revisited multiple times through the remainder of the disclosure.

[0335] Starting at the highest level with the ‘command’, it should be understood that the SPL code is written to the LOM model previously introduced (see Section D). Commands are authored against frames. Frames are objects that usually represent verbs. Basic frames, those that represent one verb, are supplied by the analysis system. A developer may also define his or her own verb frames, a feature discussed in greater detail in a section detailing Frames.

[0336]

TABLE 78
“Send Mail To Bob” SPL Code.
	//Bolded tokens are keywords or reserved
	//words.
	command SendMailCommand uses
	MySendFrame<DoneTo.what := MailEntity>
	{
	on resolve
	{
	// begin resolution clause,
	//invoked before resolution begins
	begin
	{
	// Do application specific initialization
	//or fail if we don't want further
	//resolution against this command
	//(eg the application is not in the
	// correct context/state).
	}
	// success resolution clause, invoked
	//when resolution of the utterance against
	//this object succeeds.
	success
	{
	// Do application specific task execution
	//  (generate url or xml, run the command,
	//pop up dialogs, and so on)
	}
	// failed resolution clause, invoked when
	// resolution against this object failed
	failure
	{
	// Do task specific cleanup (free resources,
	//pop up dialogs, and so on)
	}
	}
	}

[0337] The SendMailCommand defines an application task entry point that uses the MySendFrame where the object being sent (the ‘DoneTo.what’ slot) is a MailEntity. The command encapsulates the task, allows the developer to perform specific initialization and cleanup, and provides the platform with an entry point into the application.

[0338] Table 79 illustrates the SPL code for MySendFrame.

[0339]

TABLE 79
MySendFrame.
Frame   MySendFrame  :   send<DoneTo.what  :=
MailEntity>
{
on resolve
{
begin
{
// do app specific initialization or fail
}
//RecipientEntity is defined somewhere in
//the program
with restriction Goal<goal  := RecipientEntity>
{
//Code is only executed if there is a valid Goal
// relationship between MySendFrame and
// RecipientEntity in the utterance.
//
// Do application specific reasoning to bind to
// application objects, set state, or reject the
// resolution.
}
success
{
}
failure
{
}
}
}

The MySendFrame code block defines an application specific frame, MySend, that inherits from the domain independent basic “send” frame (provided by the platform) and subtypes the ‘DoneTo.what’ to a MailEntity. The ‘DoneTo.what’ is the object being sent.

[0340] The semantics of sending ‘to Bob’ are captured by the Goal restriction. (provided by the platform, e.g. the SPL based on the LOM), which is linked to ‘send’ via the ‘with restriction’ clause. In addition to this linking, the entity that is being sent “to Bob” is also grounded toga RecipientEntity.

[0341] As previously discussed, Restrictions are typed semantic relationships, usually between entities. The SPL platform provides a predefined base-set of relationships. Developers can subtype the base-set of restrictions to create their own relationships. Some examples of predefined restrictions are Location (“mail in Inbox”), Time (“delete after 3 days”), Possessor (“Bob's book”) and Topic (“mail about cats”).

[0342] One important thing about restrictions is that the variations in syntax are normalized by the semantic platform. For example, Topic can be expressed in multiple ways semantically: “mail about cats”, “mail with cats as the subject”, “mail regarding cats”, “mail with subject cats”, and the like. Different languages express the semantics of Topic differently. These variations are normalized by the semantic platform so that developers just have to program against the Topic restriction, rather than against each possible semantic variation.

[0343] Table 80 illustrates the syntax of MailEntity according to an embodiment of the present invention.

[0344]

TABLE 80
MailEntity.
	Entity MailEntity denoted by MailWords
	{
	on resolve
	{
	begin
	{
	}
	success
	{
	}
	failure
	{
	}
	}
	}
	denoter MailWords
	{
	Japanese := noun(“   ”), noun(“   ”);
	English  :=  noun(“mail”),  noun(“email”),
	noun(“electronic mail”);
	}

In this example, MailEntity is defined and is denoted by a list of words. The words that denote are usually defined separately, typically in their own file (such as a localization file).

[0345] Like frames, entities can also have restrictions applied to them. Table 81 illustrates the syntax of an entity with restrictions.

[0346]

TABLE 81
Entity with Restrictions.
	entity MailEntity denoted by MailWords
	{
	with   restriction   Location<loc   :=
	MailFolder>
	{
	}
	}

From a developer's perspective, this syntax declares that mail items can have the property (restriction) of being in a MailFolder. From an entity-relationship perspective, the MailEntity and MailFolder are related via the Location relationship. At runtime, an instance of MailEntity with the Location restriction represents the set of mail items that are restricted to being in a particular MailFolder.

[0347] For the utterance “send mail to Bob” or “send Bob mail”, the SPL runtime platform resolves against the SendMailCommand command. FIG. 4 illustrates a flow diagram tracing resolution through a SendMailCommand code according to one embodiment of the present invention. It should be understood by a worker skilled in the art that resolution of a command will vary according to the implementation. For example, referring to Table 78, each of the Begin, Success, and Failure clauses are optional. The OnResolve clause may contain any one of the clauses, any combination of the clauses, or none of the clauses, depending on the specific implementation.

[0348] For the purpose of the flow diagram in FIG. 4, it should be understood that the analysis engine has already mapped the utterance to types defined in the declarative schema and derived from the LOM. Denoter objects, for example, have already been considered by the analysis engines. Additionally, it is assumed that the code contains a Begin clause, a Success clause and a Failure clause for each element. It is also important to note that some details are omitted from the flow diagram, in part, because such details are implementation specific and would unnecessarily complicate the discussion.

[0349] Referring now to FIG. 4, upon receiving an utterance, the begin resolution clause of SendMailCommand is invoked (block 400). If begin resolution clause does not succeed, a different command may be invoked or (optionally) the Interpreter may simply fail resolution, depending on the specific implementation and depending on other commands that may be available in the application (block 402).

[0350] If the begin resolution clause of the SendMail Command is invoked successfully, the SPL Interpreter invokes the begin resolution clause for a MySend Frame that the SendMail Command uses (block 404). If the begin resolution clause for the MySend Frame fails, the SendMail Command failure clause is invoked (block 406), and the SPL interpreter can optionally invoke a different command or fail resolution (block 402).

[0351] If the begin resolution clause for the MySend Frame succeeds, the MailEntity Begin Resolution clause is invoked (block 408). If the invocation of the begin resolution clause for the MailEntity fails, then what happens next is largely implementation specific. As shown, depending on the specific implementation, failure of the MailEntity begin resolution clause may imply general failure (option 1), may be ignored (option 2), or may result in other operations to disambiguate the utterance (block 410). These “other operations” may include attempting to use a different restriction clause for the part of the input that is being resolved. The restriction clause can even be for a different restriction entirely, due to ambiguities.

[0352] If failure is understood to imply general failure (option 1), then the SPL interpreter optionally invokes a different command or fails resolution (block 402). If failure is ignored (option 2), then the SPL interpreter may simply invoke the success clause of the MySend frame (block 420), invoke the success clause of the SendMail Command (block 422), and add the SendMail Command Object to the “actual interpretation” list (block 424). If other operations are required by the developer code, then the SPL interpreter may perform further processing, including communications with the natural language analysis engines and/or call backs to the client application to attempt to disambiguate the utterance.

[0353] If the invocation of the begin resolution clause of the MailEntity succeeds, the MailEntity success clause is invoked (block 412). Next, the Restriction begin resolution clause is invoked (block 414). If the Restriction begin resolution clause fails, then the flow proceeds to block 410 (described above). If the begin resolution clause of the Restriction succeeds, the Restriction success clause is invoked (block 416). The Restriction clause is then invoked on the MySend Frame with the MailEntity slot (block 418). If this invocation fails, once again the flow proceeds to block 410 (described above). If the invocation succeeds, the success clause of MySend Frame is invoked (block 420), the success clause of the SendMail Command is invoked (block 422), and a SendMail Command object is added to the “actual interpretation” list (block 424).

[0354] It should be understood that the code blocks lead to virtually infinite permutations, depending on the application and on the developer. In one embodiment, a default for any failed resolution may be to invoke the failure clause and stop execution. In another embodiment, the developer may wish to instantiation partial objects so that the application can utilize the domain context to resolve ambiguities and to perform partial execution of the utterance. Numerous possibilities can be imagined wherein in each clause, the developer is free to write code to perform application specific functions.

[0355] In a preferred embodiment, RecipientEntity could be authored with a Named restriction clause taking a RecipientName as a slot. RecipientName would be a NamedEntity defined such that instances of recipient names would have been located in the entire user input before semantic processing was performed. This enables a robust recognition of RecipientEntity instances.

[0356] Assuming that “Bob” is a valid RecipientEntity, as previously mentioned, RecipientEntity is defined somewhere within the program. In this instance, the “with restriction” is within the MySendFrame used by the SendMailCommand. The code inside the “with restriction” clause is invoked. The code inside of the “with restriction” provides some flexibility to the developer to reject this restriction. If the clause succeeds, then the restriction is accepted. Otherwise alternative “with restriction” clauses may be invoked in succession until one of them succeeds, and if none of them do then the restriction is ignored. In an alternative embodiment, if a resolution clause fails, a fail resolution is invoked. Finally, the success clauses of MySendFrame and SendMailCommand are invoked, in that order (blocks 420 and 422).

[0357] In general, it will be understood by a worker skilled in the art that restrictions and other objects within the LOM and implemented by the SPL can be configured to invoke any number of functions or processes, either on success or failure. The flow diagram is a simple illustration to show how an exemplary flow might proceed. However, numerous other variations are anticipated and are as numerous as the potential client application to which the present invention may be applied.

[0358] During this resolution process, a connected graph is produced. Each entity is a node of the connected graph, and the relationships between the entities are defined by the LOM and validated against the application domain. It will be understood by a worker skilled in the art that the nodes and relationships are strongly typed. The connected graph represents what was said in the language of the domain.

[0359] It is important to note that the existence of the SPL objects (commands, entities, frames, and restrictions) is determined by authored code in conjunction with the semantic analysis. In general, resolving against a frame, entity, command, or restriction, involves determining the existence/validity of these objects with respect to the application domain. The objects do not really exist (are not valid) until their constraints are satisfied. An analogy of this can be drawn with C# object construction. In C#, objects can have constructors for which developers can write code to throw an exception. The exception prevents the object's existence if some constraint is not met.

[0360] The “system” invokes these constructors when it attempts to create the object. Thus, the authored code in the constructor can determine the class's existence. Conceptually, SPL resolution of its core types takes this concept a step further, formalizes it, makes it richer, and makes it a native part of the system. The constraints that must be satisfied are a combination of domain authored knowledge and semantic analysis of the utterance.

D3. Inheritance.

[0361] Concept encapsulation and compositionality are achieved through traditional object-oriented techniques (such as object reuse, inheritance, polymorphism, and the like). For example, to model “send mail to Bob” and “send instant message to Bob”, we can declare MySendFrame to take a super type of MailEntity and InstantMessage. Table 82 illustrates the MySendFrame according to an embodiment of the present invention.

[0362]

TABLE 82
MySendFrame.
	Entity ItemEntity
	{
	}
	entity MailEntity : ItemEntity
	{
	}
	entity InstantMessage : ItemEntity
	{
	}
	frame   MySendFrame:   send<DoneTo.what   :=
	ItemEntity>
	{
	on resolve
	{
	with   restriction   Goal<goal   :=
	RecipientEntity>
	{
	}
	}
	}

It is then possible to define separate commands for “send mail” and “send instant message” as follows.

• • [0363] command SendIMCommand uses MySend<DoneTo.what:=InstantMessage>;
  • [0364] command SendMailCommand uses MySend<DoneTo.what:=MailEntity>;
    The concept of “sending item to Recipient” is encapsulated by MySendFrame and can be reused by SendIMCommand and SendMailCommand. It is also possible to reuse MySendFrame compositionally. An example of this is provided in Table 83.

[0365]

TABLE 83
MySendFrame.
	entity MailEntity
	{
	on resolve
	{
	with frame MySendFrame <DoneTo.what :=
	this>;
	}
	}

In a broad sense, the above discussion captures the semantics of “mail sent to Bob.”

[0366] In general, SPL provides the ability for developers to reason about the application domain and to have that reasoning affect the analysis in a deep and meaningful way. SPL allows this reasoning to be done declaratively and procedurally. Referring again to the MailEntity syntax, the syntax establishes declarative constraints that say MailEntity is an entity that is denoted by a list of words specified in MailWords, and it can be restricted to being in a MailFolder location. Table 84 illustrates the MailEntity.

[0367]

TABLE 84
MailEntity.
	entity MailEntity denoted by MailWords
	{
	on resolve
	{
	with   restriction   Location<loc  :=
	MailFolder>;
	}
	}
	entity MailFolder denoted by FolderWords
	{
	on resolve
	{
	with   restriction   Named<name  :=
	string>;
	}
	}

Utterances such as “mail in Foo”, “mail located in folder Foo”, and the like succeed against MailEntity since the Named restriction clause on MailFolder accepts all strings.

[0368] In some instances, it may be desirable to write code to determine if “Foo” is really a currently valid folder in the current user's mailbox. The only way to do this is to write procedural code to check the validity of “Foo” at runtime. Table 85 illustrates the syntax for a MailFolder entity that checks the validity of a Folder name at runtime.

[0369]

TABLE 85
MailFolder with Procedural Check Code.
	entity MailFolder denoted by FolderWords
	{
	on resolve
	{
	bool haveName = false;
	on success
	{
	return haveName;
	}
	with restriction Named<name := string>
	{
	haveName             =
	IsValidFolderName(Named.name);
	return haveName;
	}
	}
	}

If “Foo” is not a currently valid folder, then resolution of MailFolder fails. Depending on the specific implementation details, failure may imply a general failure. Alternatively, failure of a restriction may lead to the restriction being ignored. In one embodiment, if the MailFolder resolution fails, then MailEntity also fails and so on up the resolution chain (e.g. implying general failure). In a preferred embodiment, if the resolution of MailFolder fails, then the MailFolder restriction is simply ignored. It will be understood by a worker skilled in the art that this is a simplified example. Much more complicated validity checks may be used, depending on the implementation.

[0370] Another way to achieve this effect would be to create a NamedEntity type FolderName, and use that as the slot of the Named restriction.

[0371] A nice side effect of invoking the clauses (begin, success, failure, and with restriction) is that the developer can write code to bind the semantic objects to application objects. For example, in the Named restriction clause, the developer can write code to get a reference to a folder application object if the name is valid. Table 86 illustrates the syntax for such a reference.

[0372]

TABLE 86
Code to Bind Semantic Objects to Application Objects.
	entity MailFolder denoted by FolderWords
	{
	MAPIFolder folder;
	on resolve
	{
	with restriction Named<name:=string>
	{
	folder=GetFolder(name);
	if(folder==null) return false;
	}
	}
	}

This syntax effectively binds an application specific object, MAPIFolder, to the semantic object, MailFolder.

[0373] In general, developers can easily write code to reason about their application context and state at key points in the analysis. This reasoning can affect the end resolution analysis. For example, to determine if “Bob” is a valid recipient or not, the developer can write code that goes to a database of current users of the system. If not, the developer could write code to handle the failure. For example, the developer can display a pop-up window or dialog for user clarification, generate restatement, and the like, right at the point of failure. By providing immediate feedback to the user at the point of failure, the system fosters the appearance of a smart, well-developed application.

[0374] Alternatively, the developer can write code at the top level SendMailCommand to prevent resolution against the command if the application is not in an appropriate state. This deep integration between semantic analysis and reasoning about domain knowledge is very important to understanding and disambiguating natural language.

[0375] By allowing developers to write code in clauses to reject resolutions, SPL enables the developer to make early rejections of incorrect analyses. In general, the author can assert a lot of control over the interpretations that succeed and those that fail. In some instances, it may be desirable for the author to reject some interpretations at early stages of the process. In general, the earlier the author can disambiguate (remove ambiguities), the easier it is for the application to manage ambiguity. Less ambiguity means fewer interpretations. Any application authored for natural language must have some mechanism for managing multiple interpretations. The author either writes code to evaluate the sanity of interpretations as the interpreter is deciding, or writes code that occurs after semantic analysis is done to disambiguate and pick among the set of interpretations (post processing). It is not hard to see that the former would be easier to manage and code for.

[0376] Additionally, it is believed that the earlier interpretations can be rejected, the faster and more accurately the best interpretation can be found.

[0377] In some instances, authors may wish to reject interpretations later in the process. Rejecting interpretations earlier quite often involves making call backs into the client application to examine state and/or context and to reason about the application's object model. If the call backs need to go over a network, then making frequent call backs can cause the system to operate slowly. For example, transmission delays could render the system unusable. SPL allows the author to have complete control over when and what call backs to make. Thus, the developer can decide for himself (herself) what the right balance of call backs and post-analysis disambiguation logic is, depending on the nature of the client application.

[0378] Alternatively, in some implementations, the developer may want to reason about the entire resolution before deciding whether to reject resolutions or not. There could be cases where the pieces in isolation cannot determine success or failure and global reasoning over the resolved tree is required.

[0379] SPL lets the developer choose how to balance early versus late rejection depending on their needs and the needs of the client application.

[0380] As previously discussed, the resolution of the frames, restrictions, and entities by the SPL runtime is essentially building a domain dependent model of an utterance. This statement warrants elaboration.

[0381] In natural language, a syntactic construct can be used to express a multitude of meanings. As a very simple example, consider the preposition “on” followed by a noun. For example, consider the phrase “on Foo”. The phrase “on Foo” can refer to a Location (as in “book on table”) or it might mean Topic (as in “book on Seattle”). To determine which phrase is correct, the phrase must be disambiguated. This disambiguation can only be done by the application. For example, Table 87 illustrates the syntax for enabling Amazon.com.

[0382]

TABLE 87
Book Seller Syntax.
	entity BookEntity denoted by “book”
	{
	on resolve
	{
	with restriction Topic<topic := string>;
	}
	}

When resolving “book on Foo”, the semantic analysis would not produce the Location object since BookEntity only understands Topic. The resolved model of what was said will not contain Location. This “directing” is even more evident in the modeling of coordination (and/or), negation, and clauses.

[0383] For coordination, the SPL code defines how entities and their modifiers are distributed over conjunction and disjunction. For the Utterance, “find mail and notes created yesterday”, the possible modeling choices include:

• • [0384] 1. Find (mail created yesterday) and (notes, created yesterday).
  • [0385] 2. Find (mail) and (notes created yesterday).
  • [0386] 3. Find (mail created yesterday) and find (notes created yesterday).
  • [0387] 4. Find (mail) and find (notes created yesterday).
    How “created yesterday” and “find” are distributed with its entities, “mail” and “notes”, is determined by the authored code. The possible readings are even greater for utterances containing both conjunction and disjunction. It is not necessary for the author to understand all possibilities. Authors just think in terms of the semantics of their application. For example, as a SPL author, it is possible to code the FindMailCommand such that my FindMailCommand only understands entities of type MailEntity and my FindNotesCommand only understands entities of type NotesEntity. Furthermore, MailEntity does not have the notion of creation time (this is just for illustration purposes), but NotesEntity does. Therefore, for the above utterance, “find mail and notes created yesterday”, the semantic analysis will only produce reading 4 from the above list.

[0388] For negation, the authored code determines how negation scope ambiguity is modeled. For example, take the utterance, “Don't allow mail from Joe”. The phrase can be interpreted as follows:

• • [0389] 1. Don't allow mail from Joe (block it instead): negation scoped “allow”;
  • [0390] 2. Don't allow mail from Joe (but allow messages from him):negation scoped over “mail”; or
  • [0391] 3. Don't allow mail from Joe (but allow mail from someone else): negation scoped over “Joe”.
    The authored SPL program determines how the negation is scoped and modeled. The semantic analysis engines provide all the possible readings.

[0392] For clauses, the authored code determines whether the clause is modeled as a frame-based restriction (restrictions that are headed by verbs) or as one of the predefined restrictions. For example, “book that discusses Foo”, the clause, “that discusses Foo”, can be modeled as a Topic restriction or it can be modeled as a frame-based restriction on “book”. Table 88 provides an example of the syntax for the BookEntity.

[0393]

TABLE 88
BookEntity.
	Entity BookEntity denoted by “book”
	{
	on resolve
	{
	with frame discuss<DoneTo.what := string>;
	}
	}

[0394] In general, from the perspective of the SPL, the role of the SPL program is to define a natural language semantic model of the application's domain. The role of the semantic analysis is to map utterances to that SPL Program-defined model in accordance to the analysis engines' understanding of linguistics.

[0395] From platform's point of view, the role of the semantic platform is to define a highly abstract, domain-independent object model of what is said. From this perspective, the role of the SPL code is to pick from the possibilities the platform provides.

[0396] In general, the resolution of a SPL program can be understood as building the domain-dependent semantic model of what is said. In the process of building this domain-dependent model, domain-independent objects become strongly typed and can be anchored (mapped) to the application's objects.

E2. Type System

[0397] In general, the core SPL types are commands, frames, entities, and restrictions. These are called resolvable types because they require resolution semantics to determine their existence.

[0398]

	[resolvable type]
	{
	on resolve
	{
	begin
	{
	}
	success
	{
	}
	fail
	{
	}
	}
	}

Everything within the “on resolve” clause has to do with resolution semantics. The begin, success, and fail clauses are all optional. There can be at most one of each clause in the “on resolve”.

[0399] The begin clause is invoked at the beginning of resolution of the resolvable type. By default, the clause returns ‘true’. The developer can return ‘false’ which signals to the SPL interpreter to stop resolution against this type. This means the resolution fails, and the fail clause is invoked. The begin clause is a convenient place for the developer to do initialization and to check whether the application is in an appropriate context/state to process the type.

[0400] The success clause is invoked when resolution against the type succeeds. This is where the developer can write code to cleanup resources or to package up the resolution result. The developer can still reject the resolution by returning false.

[0401] The fail clause is invoked when resolution fails to succeed. Like the begin and success clauses, the fail clause can return ‘false’ which will effectively make the failed resolution of the type succeed.

[0402] In one embodiment, all resolvable types, except for the command, can have any number of restriction clauses. This is discussed in more detail with respect to Slots and “with restriction/Frame clauses”. In an alternative embodiment, all resolvable types, including the command type, can have any number of restriction clauses. Each of the resolvable types (Commands, Frames, Entities, and Restrictions are discussed in detail below.

[0403] Commands are Natural Language (NL) enabled tasks supported by the client application. During development of the client application, authors create commands to describe the actions they want to handle. Commands provide the semantic analysis with task entry points into the application. SPL resolution begins at the command and recurses down the tree. Commands are invoked in response to user commands. This is analogous to the way Windows events such as mouse click are invoked in response to a user clicking a mouse. Table 89 shows the syntax of the command declaration according to an embodiment of the present invention.

[0404]

TABLE 89
Command Declaration.
	Command CommandName uses FrameObject <optional slots>
	{
	}

For example, “Command SendMailCommand uses MySendFrame” defines a SendMailCommand object that uses the MySendFrame object. Commands essentially wrap frame objects. Only one frame object can be specified in a command.

[0405] The begin clause in a command is a useful place to check whether the application is in an appropriate context and/or state to process the command. This allows for very early rejection of a command based on application knowledge.

[0406] In the success clause, the developer can directly execute the command or package up whatever data is needed to execute the command. This packaged data can be in the form of a URL, an XML description of the task, a delegate to the function that can execute the command, and the like. The author can still do additional reasoning in the success clause and reject the interpretation by returning a value of “false”. This is useful because it permits the author to reason globally about the whole utterance. In other words, the author can look at the completely resolved semantic tree to see if the resolution as a whole is coherent. The pieces may be coherent independently or in a limited context, but they may not make sense together.

[0407] An “Unknown” command handles utterances that do not map to an authored command. In one embodiment, SPL enforces the existence of this command.

[0408] Frames generally refer to verbs. There are two types of Frames: basic frames and composite frames. A basic frame refers to one verb. For example, the frame find refers to the verb “find”. A composite frame is a grouping of multiple verbs, which generally have the same meaning. The composite frame and its multiple verbs can be thought of as a synonym lists. In general, the semantic platform provides a predefined set of basic frames, one for every verb. For consistency, the convention is the names of the basic frames are lower-case, and they have the same name as their corresponding lexical word. By contrast, a name of a composite frame begins with a capital letter. The semantic platform provides a set of composite frames that are common. For example, the platform can provide a Search composite frame that groups together “find”, “search”, “look” and “rummage”.

[0409]

TABLE 90
Basic Frame.
	frame FrameName denoted by “word” behaves as
	VerbClass
	{
	}

For example, the syntax for the find frame is shown in Table 91.

[0410]

TABLE 91
Find Frame.
	frame find denoted by “find” behaves as
	DefaultVerbClass
	{
	}

This syntax defines a basic frame, find, that is denoted by the lexical word, “find”, and that behaves in the DefaultVerbClass. The term “find” is referred to as a denoter that denotes the frame, find. The semantic platform defines a set of verb class behaviors that covers all verbs. A large majority of verbs have behaviors that are part of the DefaultVerbClass.

[0411] The lexical words do not have to appear inline. In fact, in order to support multiple languages, it is recommended that the words do not appear inline. They should be defined in their own object. Table 92 illustrates the syntax for a defined denoter object.

[0412]

TABLE 92
Denoter Object.
	denoter FindWord
	{
	English := “find”;
	French := “chercher”;
	}

By listing the denoter terms separately in this manner, rather than inline with the frame definition, the language dependent elements are separated nicely from the language independent ones.

[0413] All basic frames that are provided by the semantic platform are defined in SPL code in this manner. Developers can also define their own verbs this way. For example, in one embodiment a developer can define a fop base class as follows:

• • [0414] frame fop denoted by “fop” behaves as DefaultVerbClass;
    Alternatively, in a preferred embodiment, a developer can define a fop base class as follows:
  • [0415] frame fop denoted by “fop;
    It is believed that a very large majority (around 95%) of the verbs will have their linguistic realizations as the lexical words themselves. In most cases, there will be a fairly direct translation to the other languages. For verbs that do not behave in this manner across languages, a mechanism is provided in the denoter class to specify linguistic realization of those verbs.

[0416] As mentioned above, composite frames are groupings of verbs. They are essentially synonym lists. In creating composite frames, only the denoters of the frames used in the groupings are “inherited” by the composite frame.

[0417] SPL provides developers with the ability to create their own groupings from basic and composite frames. An example is provided in Table 94

[0418]

TABLE 94
Composite Frame.
	frame CompositeName groups frame1, ..., framen
	except framex, ..., framey
	{
	}

Essentially, this declaration establishes a logical union of all the denoters of the frames specified in the groups clause, removes duplicates, and then removes the denoters of the frames specified in the except clause. The except clause is optional. For example, Table 95 illustrates a composite frame containing an except clause in the definition.

[0419]

TABLE 95
Composite Frame with Except Clause.
	frame MySearchFrame groups Search, fop except find
	{
	}

This defines a MySearchFrame that groups together the denoters of Search and fop except for the denoters of find frame.

[0420] Derived frames can also be created that inherit from other frames, either basic frames or composite frames. Table 96 illustrates the syntax for a Derived frame.

[0421]

TABLE 96
Derived Frame.
	Frame DerivedFrame : BaseFrame<slot1, ... , slotn>
	{
	}

The subject of Inheritance is discussed in greater detail in Section E3 below.

[0422] Entities are the objects that can be referred to, either by name or by a description, in the application. Entities can be concrete things, like file items and email items, but they can also represent abstract concepts, such as color, texture and so on. Entities are usually denoted by lexical words. Table 97 shows the syntax for declaring an Entity.

[0423]

TABLE 97
Entity Declaration.
	entity EntityName denoted by “word1”, ..., “wordn”
	{
	}
	For example:
	entity MailEntity denoted by “mail”, “electronic
	mail”, “email”
	{
	}

Like frames, it is recommended that the denoters are not specified inline in order to support multiple languages. Table 98 provides an example of such denoters.

[0424]

TABLE 98
Denoters
	entity MailEntity denoted by MailWords
	{
	}
	denoter MailWords
	{
	Japanese := noun(“  ”), noun(“  ”);
	English := noun(“mail”), noun(“email”),
	noun(“electronic mail”);
	}

The denoted by clause allows authors to specify a list of natural language words that denote the entity. The denoted by clause is the means by which the developer grounds entities to lexical words. Entities do not need to be denoted by a word or a group of words. Entities can be described by their restrictions. The developer does not need to specify the various forms of a word (such as “file” and “files”), because the forms are taken care of by the semantic platform. Additionally, the denoters do not need to be specified in the utterance in order for the entity to succeed. However, if a denoter is contained in the utterance, the denoter must match one of the denoters in the entity's list.

[0425] In some embodiments, it may be desirable that the denoter is optional at the declaration. Additionally, it may be desirable, in some implementations, to add obligatory denoters (words that must be contained in the utterance for the entity to succeed). The presence of an “obligatory” denoter can be enforced through code contained in the success clause. Table 99 shows an example of an obligatory denoter enforced through the success clause.

[0426]

TABLE 99
Obligatory Denoter Enforce through Success
Clause.
	entity MailEntity denoted by MailWords
	{
	on resolve
	{
	success
	{
	if (this.Denoter == null)
	return false;
	}
	}
	}

[0427] In general, restrictions are typed semantic relationships. The platform provides a predefined base set of relationships. One of the most important things about restrictions is the normalization of variations in syntax, both within a language and across languages. Restrictions are semantic, not syntactic. Thus, the restrictions allow the developer to code against semantics of the language, not the syntax. Restrictions greatly ease the authoring burden and make enabling for other language possible.

[0428] Some restrictions come with system-defined slots that have specific meanings. The discussion of the LOM in section D above provided code samples and some discussion of slots. Some common restrictions are listed below in Table 100.

[0429]

TABLE 100
List of Common Restrictions.
	Restriction Syntax	Application
	Doer<who := Entity>	Applies to frames. It
		represents the entity doing the
		action. Examples: “Bob opened
		the file”, “the file was opened
		by Bob”.
	DoneTo<what:= Entity>	Applies to frames. It
		represents the entity that the
		action is being done to.
		Examples: “open the file”, “the
		file was opened”.
	Location<loc:=Entity>	Models the semantics of being
		located somewhere. Examples:
		“mail in Inbox”, “file located
		on the desktop”.
	Time	Models actual time expressions,
		i.e. expression that can be
		converted into a point and/or
		span in time. Examples: “delete
		after 3 days”, “mail from
		yesterday”, “schedule for
		tomorrow from 1–3 pm”.
	Topic<topic    :=	Models subject matter.
	Entity>, Topic<topic	Examples: “book about dogs”,
	:= string>	“book regarding dogs”, “book
		with the subject dogs”.
	Source<src := Entity>	Models object or source.
		Examples: “mail from Bob”
	Order	Examples: “sort in alphabetical
		order”, “display in reverse
		order by name”
	Cardinal	Example: “3 files”
	Ordinal	Example: “first file”
	Means<instrument  :=	Examples: “search using
	Entity>	Google”, “open with Word”
	Possessor<owner  :=	Examples: “my book”, “Bob's
	Entity>	book”
	Accompaniment	Example: “meeting with Bob”
	Degree	Examples: “almost in the box”,
		“extremely red”, “very large”,
		“more to the left”
	Negation	Examples: “not from Bob”,
		“don't send mail”, “except for
		Bob”
	Named<name := string>	This represents the name of an
		entity. Examples: “Inbox
		folder”, “file named foo.txt”
	Modifier<mod    :=	This represents adjectival
	Denoter>	modifiers. Examples: “large
		file”, “school bus”

[0430] There is a special restriction called a Default restriction. The Default restriction is fired by the SPL runtime when there is an unresolved or unrecognized restriction on the resolvable type.

[0431] Developers create their own restrictions by inheriting from one of the predefined set of restrictions, by creating a frame based restriction, or by specifying a pattern.

[0432] In general, restrictions can be applied to entities and to frames, as well as to other restrictions. As a general rule, SPL does not enforce whether applying a certain restriction makes semantic sense. SPL makes some exceptions either to simplify the semantic modeling or to reduce the ambiguity. The exceptions are presented in Table 101 below.

[0433]

TABLE 101
SPL Exceptions.
1.	Degree restriction is only allowed on
	restrictions.
2.	Doer and DoneTo restrictions are only
	allowed on frames.
3.	Negation is not allowed on entities.

Restrictions are applied to a type using the following syntax:

• • [0434] with restriction RestrictionName<slot₁:=type, . . . , slot_n:=type>;
    The arguments in the angle brackets are called slots. The “with restriction” statement is called the restriction clause. The label “restriction” was chosen to avoid certain problems. For example, restrictions could be labeled “properties”, but properties does not always work as a descriptor. For example, one can think of “mail in Inbox” as “mail with the property of being in the Inbox folder”. However, this same relationship does not exist with quantifiers, such as cardinals and ordinals. The phrase “three files” is not equivalent to “files with the property of three”. Moreover, the word “property” is already used in conventional programming paradigms (e.g. “properties of a list box”). It is generally desirable not to overload the term “properties”, and the same holds true for the word “attribute”.

[0435] Instead, Entity is intended to convey the notion of sets. The “entity” declaration in SPL is really specifying a set of entities, and applying restrictions is restricting that set. For example, the syntax for declaring a MailEntity denoted by Mail

• • [0436] entity MailEntity denoted by “mail”
    is a declaration of an object that represents the set of all mail items. Table 102 illustrates the syntax for a restriction applied to an entity.

[0437]

TABLE 102
Restriction Applied to an Entity.
	Entity MailEntity denoted by “mail”
	{
	on resolve
	{
	with  restriction  Location<loc  :=
	MailFolder>;
	}
	}

Here, the set of mail items is restricted to a MailFolder location.

[0438] Applying restrictions to frames should be viewed as restricting that action (Frames typically model verbs or actions). Table 103 illustrates a Frame with a restriction.

[0439]

TABLE 103
Restriction on a Frame.
	frame MyOpen : open<DoneTo.what := FileEntity>
	{
	on resolve
	{
	with  restriction  Means<instrument  :=
	NotepadEntity>;
	}
	}

Here, the Means restriction is applied on MyOpen frame, thereby restricting the open file action to use Notepad.

[0440] The same applies to restrictions on restrictions. For example, the Cardinal restriction represents cardinality of an entity. The phrase “3 files” means any 3 files. However, the cardinality can be restricted by an Ordinal, as in “first 3 files”. Table 104 illustrates a restriction applied on a restriction.

[0441]

TABLE 104
Restriction on Restriction.
	restriction OrdinalCardinal : Cardinal
	{
	on resolve
	{
	with restriction Ordinal;
	}
	}

Here, the restriction clause restricts the cardinal by applying an ordinal.

[0442] In general, resolvable types, except for commands, can have any number of restrictions applied to them. Each restriction type can be applied multiple times as long as the signature is unique. Table 105 shows a Frame having multiple restrictions with unique signatures.

[0443]

TABLE 105
Frame with Multiple Restrictions.
	frame MyOpen : open<DoneTo.what := FileEntity>
	{
	on resolve
	{
	with restriction Means<instrument	:=
	NotepadEntity>;
	// valid restriction clause
	with  restriction  Means<instrument	:=
	MSWordEntity>;
	// invalid restriction clause because
	//the signature is not unique
	with  restriction  Means<instrument	:=
	NotepadEntity >;
	}
	}

The order in which the restriction clauses fire is dependent on the semantic analysis. In general, the order is based on a combination of linguistic evidence, statistical ranking, and domain-dependent learning. Mechanisms may be added, in certain implementations, to force a deterministic order. The SPL runtime fires the restriction clauses in accordance to SPL's language semantics and the semantic analysis.

[0444] As mentioned above, slots are the arguments that appear in angle brackets (< >). Slot syntax is used to subtype the slots at point of use. The SPL has a plurality of predefined slots of restrictions. For example, the semantic system defines a Goal restriction as follows:

• • [0445] Goal <goal:=Entity>
    The goal slot has the base Entity type, and can be referred to as a domain-independent specification. When the developer applies this domain-independent Goal to a resolvable type, the developer can subtype the goal slot at the point of application. Table 106 shows the syntax of Frame containing a subtyped goal slot.

[0446]

TABLE 106
Frame with Subtyped Goal Slot.
	frame send denoted by “send”
	{
	on resolve
	{
	// models “send to ContactItem”
	with restriction Goal<goal := ContactItem>;
	}
	}

Here, the developer has sub-typed the goal slot to a ContactItem (ContactItem must be an entity type).