Resolvable semantic type and resolvable semantic type resolution

• US 7,681,186 B2
• Filed: 09/15/2004
• Issued: 03/16/2010
• Est. Priority Date: 04/23/2004
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Parkinson, David J., Cipollone, Domenic J., Calcagno, Michael V., Olsen, Mari J. B., Chang, Su Chin, Shahani, Ravi C.
• Primary Examiner(s): Yigdall; Michael J.
• Assistant Examiner(s): Wang; Ben C
• Application Number:
  US10/942,646
• Publication Number:
  US 20050273771A1
• Time in Patent Office: 2,008 Days
• Field of Search: None
• US Class Current: 717/143
• CPC Class Codes: G06F 40/30 Semantic analysis
• CPC Class Codes: G06F 8/20 Software design
• CPC Class Codes: G06F 8/315 Object-oriented languages
• CPC Class Codes: G10L 15/18 using natural language modelling
• CPC Class Codes: G10L 15/1815 Semantic context, e.g. disambiguation of the recognition hypotheses based on word meaning
• CPC Class Codes: Y10S 707/99944 Object-oriented database structure

Abstract

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 the resolvable types in a natural language enabled software application.

Claims

1. A computer readable storage medium embodying processor readable instructions executable by a processor to produce natural language enabled software applications, the processor readable instructions comprising:

resolvable types comprising representations of linguistic elements that are different from the linguistic elements themselves and interrelationships among the linguistic elements of a natural language input the linguistic elements being words in the natural language input; and

resolution semantics defining procedural rules for resolving validity of instances of the resolvable types in a natural language enabled software application, the resolution semantics including a configurable framework comprising;

a first clause causing the processor to initialize the resolvable type to produce an object of the resolvable type and to determine whether the natural language enabled software application is in an appropriate state to process the resolvable type;

a second clause causing the processor to discard unused objects and to process a result associated with the resolvable type when the initialization succeeds and when the natural language enabled software application is in the appropriate state; and

a third clause causing the processor to return a failure indicator when the initialization fails or when the natural language enabled software application is not in the appropriate state to process the resolvable type.

2. The computer readable storage medium of claim 1 wherein the validity of instances of the resolvable types is resolved at runtime according to the resolution semantics.

3. The computer readable storage medium of claim 1 wherein the resolvable types comprising:

a Command type for modeling natural language enabled tasks supported by a client application.

4. The computer readable storage medium of claim 1 wherein the resolvable types comprising:

a restriction host type adapted to accept constraints.

5. The computer readable storage medium of claim 4 wherein the resolvable types further comprising:

an Entity type for modeling semantics of noun phrases and adjective phrases;

wherein the Entity type inherits from the Restriction host type.

6. The computer readable storage medium of claim 4 wherein the resolvable types further comprising:

a Restriction type for modeling properties of semantic elements;

wherein the Restriction type inherits from the Restriction host type.

7. The computer readable storage medium of claim 4 wherein the resolvable types further comprising:

a Frame type for modeling a semantic event that can be expressed either as verbs or nouns;

wherein the Frame type inherits from the Restriction host type.

8. The computer readable storage medium of claim 1 further comprising:

a Denoter type for modeling user-defined categories of input strings.

9. A method for determining validity of an instantiation of a resolvable type in a natural language enabled software program comprising:

assembling a proposed interpretation list comprising proposed interpretations of a natural language input using a natural language enabled software program executing on a processor of a computing system, each proposed interpretation comprising one or more commands and optionally non-command elements mapped to resolvable types; and

determining validity of an instantiation associated with each proposed interpretation via the natural language enabled software application, wherein determining the validity comprises;

initiating resolution of resolvable types via a first clause of a semantic resolution framework configured to initialize the resolvable type to produce an object of the resolvable type and to determine whether the natural language enabled software application is in an appropriate state to process the resolvable type;

executing a second clause of the semantic resolution framework to discard unused objects and to package a result associated with the resolvable type when the initialization succeeds and when the natural language enabled software application is in the appropriate state; and

returning a failure indicator via a third clause of the semantic resolution framework when the initialization fails or when the natural language software application is not in the appropriate state to process the resolvable type.

10. The method of claim 9 wherein the step of assembling comprises:

receiving a list of potential interpretations of the natural language input comprising linguistic objects assembled by one or more natural language analysis engines associating elements of the natural language input to resolvable types of a linguistic object model;

resolving a Command associated with each potential interpretation from the list; and

adding each potential interpretation associated with a successfully resolved Command to the resolved interpretation list.

11. The method of claim 9 wherein the resolvable types comprise:

command types adapted to model commands in a natural language input; and

restriction host types adapted to model non-command elements of the natural language input, the restriction host type adapted to link to selected command types based on the natural language input and to host constraints of the selected command types at runtime.

12. The method of claim 11 wherein each proposed interpretation comprises a hierarchically linked object comprising a command type at a top level and restriction host types below the top level and linked to the command type, wherein the method of determining comprises:

invoking the hierarchically linked object in hierarchical order from a top level down; and

determining validity of an instantiation of the hierarchically linked object in reverse order.

13. The method of claim 11 wherein the resolvable types further comprise:

resolution semantics in part defined by program code within the resolvable types.

14. A computer readable storage medium embodying processor readable instructions executable by a processor to produce a natural language enabled software application, the processor readable instructions comprising:

a set of resolvable types adapted to model semantics of a natural language for natural language programming, the set of resolvable types comprising;

a command type adapted to model commands in a natural language input; and

a restriction host type adapted to represent non-command elements of the natural language input, the restriction host type adapted to host constraints associated with selected command types at runtime; and

a semantic framework configured to process the selected command types, the semantic framework comprising;

a first clause to initialize each command type and to determine whether the natural language enabled software application is in an appropriate state to process the command type;

a second clause including logic to examine a resolved semantic tree associated with the natural language input to determine if the resolved semantic tree is coherent and to process the command type when the resolved semantic tree is coherent and the natural language enabled software application is in the appropriate state; and

a third clause to return a failure indicator when the initialization fails or when the natural language enabled software application is not in the appropriate state to process the command type.

15. The computer readable storage medium of claim 14 wherein each instance of a resolvable type inherits properties of the resolvable type from which it derives and inherits relationships between the resolvable type and other resolvable types.

16. The computer readable storage medium of claim 15 further comprising:

resolution semantics defining procedural rules for resolving validity of the resolvable types in a natural language enabled software application;

wherein the resolution semantics are inherited by types derived from restriction host types and command types.

17. The computer readable storage medium of claim 14 wherein the restriction host type is adapted to associate to selected command types or to other restriction host types that are transitively associated with a selected command type based on the natural language input.

18. The computer readable storage medium of claim 14 wherein the restriction host type comprises:

Entities adapted to model semantic objects;

Frames adapted to model events and associated relationships between one or more objects; and

Restrictions adapted to model properties of and relationships between other entities, Frames or restrictions.

19. The computer readable storage medium of claim 14 wherein multiple inheritance is not permitted for types derived from the restriction host type.

20. The computer readable storage medium of claim 14 further comprising:

resolution semantics defining procedural rules for resolving validity of the resolvable types in a natural language enabled software application.