Abstract:
A system for resolving structural ambiguities in syntactic analysis of natural language, which ambiguities are caused by prepositional phrase attachment, relative clause attachment, and other modifier-modifiee relationships in sentences. The system uses instances of dependency (modification relationship) structures extracted from a terminology dictionary as a knowledge base. Structural ambiguity is represented by indicating that a word in a sentence has several words as candidate modifiees. The system resolves such ambiguity by 1) first searching the knowledge base, which contains dependency information in the form of tree structures, for dependencies between the word and each of its possible modifiees, 2) then assigning an order of preference to these dependencies by means of a path search in the tree structures, and 3) finally selecting the most preferable dependency as the modifiee. The sentences can be analyzed by a parser and transformed into dependency structures by the system. The knowledge base can be constructed automatically, since the source of knowledge exists in the form of texts, and knowledge bootstrapping can be realized by adding the outputs of the system to its knowledge base.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     This invention :relates to natural language processing systems and more particularly to an apparatus and method for resolving structural ambiguities in sentences, using knowledge of the dependencies among words in sentences of natural language, and further to a method for constructing a knowledge base used in this connection. The term &#34;words&#34; herein signifies parts of speech such as nouns, verbs, adjectives, adverbs, and other semantic words, but excludes articles, repositions, and other functional words. A semantic unit of successive words is also regarded as one word in some fields. For example, in documents related to computer technology the expression &#34;virtual disk&#34; is regarded as one word. The term &#34;dependency&#34; indicates a modifier-modifiee relationship among words. 
     2. Prior Art 
     Resolution of structural ambiguities in sentences still remains a difficult problem for natural language processing systems. An example of tile problem is offered by prepositional phrase attachment ambiguities. The sentence, &#34;A user can log on the system with a password.&#34;, is ambiguous as to whether the prepositional phrase &#34;with a password&#34; is attached adverbially to the verb &#34;log on&#34; or as a postmodifier to the noun phrase &#34;the system.&#34; 
     Some methods have been proposed for resolving structural ambiguities in sentences based on semantic and functional information on words, phrases, and other constituent elements. One such method is theoretically based on the case grammar disclosed in the article entitled, &#34;Toward a modern theory of case&#34; by Chares J. Fillmore on pp. 361-375 of &#34;Modern Studies in English&#34;, published in 1969 by Prentice-Hall. The functions of the constituent elements of a sentence for a predicate are called cases, and semantic case functions are specifically called semantic cases (see appended Table 1). 
     In case grammar, each constituent element of a sentence is called a case element, and the adequacy of a sentence is evaluated by matching the cases and the case elements. Taking the above-indicated sentence as an example, the term &#34;log on&#34; is a predicate, while &#34;a user&#34; functions as an agent, &#34;the system&#34; as an object, and &#34;a password&#34; as an instrument. Each verb is assigned to a framework called a case frame in which the case of each verb and the constraint conditions of case elements with respect to the verb are described. 
     In case grammar, acceptable case elements for a case are defined, and any input outside the definition is rejected as being semantically inadequate. In practical language usage, however, the boundary between semantically acceptable and non-acceptable sentences is a delicate one, and this also depends on the content. For example, in the sentence, &#34;My car drinks gasoline.&#34;, if the predicate &#34;drink&#34; merely accepts a word indicative of a human (a word having the semantic attribute HUM) as its agent, the term &#34;car&#34; is rejected as the agent of &#34;drink.&#34; However, if &#34;the car&#34; is considered to be used metaphorically, the term &#34;car&#34; is semantically accepted as an agent of the term &#34;drink&#34;. In a system such as case grammar that uses attribute values, it is easy to construct knowledge, but its application lacks flexibility. 
     Japanese Published Unexamined Patent Application 63-91776 discloses a method using statistical information on the frequency of words to calculate the degree of preference of syntactic analysis trees for solving structural ambiguities. A summary of the method is given below, and some problems with it are explained. 
     (1) Multiple analysis trees are actually produced from an incoming sentence, and an acceptable one is selected from among them. It is troublesome to make multiple parse trees. 
     Furthermore, it is necessary to use information even on words that are closely related to the ambiguities. 
     (2) The statistical frequency of co-occurrence relationships between words is used to solve ambiguities. Therefore, individual exceptions cannot be dealt with. For example, when an ambiguity exists as to whether a certain word A modifies word. B or word C, the method does not consider that although it is statistically usual for A to modify B, in a certain particular sentence it modifies C. Further, since this method requires sufficiently formalized data (for example, registration of &#34;virtual machine&#34; as &#34;machine is virtual&#34;), collecting data is very costly. 
     (3) In general, the number of words in natural languages is enormous. In this connection, a category called the semantic marker, which is obtained by abstracting words, is established in order to extend the coverage range. However, it must be rearranged for a different field. For example, the term &#34;department&#34; is classified into the category of organization in a certain field P, and knowledge on the attachments of &#34;department&#34; is absorbed into statistical information on co-occurrence relationships between the organization category and another category. However, when the term &#34;department&#34; is classified into another category in a different field Q, the knowledge in field P is useless in field Q. It is very costly to re-abstract words and re-collect statistical information for each field. 
     Problems to be Solved by the Invention 
     As will be seen from the above description, practical semantic processing in natural language processing involves two problems. One is efficient construction of the requisite large-scale knowledge base. The other is a mechanism for efficient use of that knowledge base. 
     An object of the invention is to provide a natural language semantic analysis system that overcomes these two problems and is acceptable for practical use, 
     SUMMARY OF THE INVENTION 
     Structural ambiguity, which is the greatest bottleneck in the analysis of natural language sentences, is caused by the presence of multiple modifier-modifiee relationships (dependencies) among words. Such structural ambiguity cannot be solved by grammatical knowledge alone, but requires semantic processing. From this viewpoint, the invention overcomes the problem by preliminarily defining dependencies among words as background knowledge and referring to this background knowledge, stored in a knowledge base, in order to select an adequate dependency among candidate dependencies. More specifically, when the system obtains a structure, including multiple attachment candidates, as a result of syntactic analysis of a sentence, it then obtains the degree of preference of dependencies among words in the sentence, based on the dependencies among the words stored as the background knowledge, and can determine which attachment is preferable. 
     With the system of the present invention, in order to solve the problem of structural ambiguity, a knowledge base is first created and knowledge, expressed in the form of tree structures indicative of synonym relationships, taxonym relationships, and dependencies among words, is stored as background knowledge in the knowledge database. Then, when a sentence is entered into the system and syntactically analyzed, the system searches for dependencies among words defined by the background knowledge, using synonym relationships and taxonym relationships. Subsequently, using a consistency condition obtained from the sentence and one obtained from the context, the system selects, by means of a path search, the most acceptable attachment and solves the ambiguity. The select call attachment or syntactic tree is output for use and the dependency structure decided upon is registered in the knowledge base as context dependency data. 
     Therefore, a natural language analysis apparatus according to the invention can be used for sentence analysis in machine translation systems, question-and-answer systems using natural languages, and so on, to output the most preferable syntactic tree, in response to an incoming sentence that includes structural ambiguities, by using knowledge on synonym relationships, taxonym relationships, and dependencies among words. Consequently, the system can be used to solve problems that are insoluble by granular-based analysis, such as ambiguities that can only be solved by the use of expert knowledge proper to a specific field or by referring to the contents of a preceding sentence. 
     A common characteristic of conventional analysis methods is that information the words should preliminarily have associated therewith, such as attributes for semantic classification, is very abundant and this information is heuristically determined by human beings. In contrast, information required for natural language analysis according to the invention is described relatively formally, and large-scale new background knowledge can be constructed automatically or semi-automatically during the analyzing process, thus making it relatively easy to construct a practical system. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is an illustrative diagram of an arrangement of a natural language analyzing system according to the invention; 
     FIG. 2 is an explanatory diagram of a phrase structure including ambiguities; 
     FIG. 3 is an explanatory diagram of a dependency structure including ambiguities; 
     FIG. 4 is an explanatory diagram of possible dependency candidates; 
     FIG. 5 is an explanatory diagram of an example of phrase structure; 
     FIG. 6 is an explanatory diagram of an example of dependency structure; 
     FIG. 7 is an explanatory diagram of dependencies and semantic cases; 
     FIG. 8 is an explanatory diagram of a taxonym relationship; 
     FIG. 9 is an explanatory diagram of a synonym relationship; 
     FIG. 10 is an explanatory diagram of a path; 
     FIG. 11 is an explanatory diagram of the node location of a word on a dependency structure tree; 
     FIG. 12 is an explanatory diagram of an &#34;isa&#34; tree; 
     FIG. 13 is an explanatory diagram of a transition of a dependency; 
     FIG. 14 is an explanatory diagram of a path from word c to word a; 
     FIG. 15 is an explanatory diagram of the dependency between &#34;keep&#34; and &#34;virtual disk&#34;; 
     FIG. 16 is an explanatory diagram of a path from &#34;virtual disk&#34; to &#34;keep&#34;; 
     FIG. 17 is an explanatory diagram of a co-occurrence relationship; 
     FIG. 18 is an explanatory diagram of the depedency structure in a knowledge base; 
     FIG. 19 is an explanatory diagram of a co-occurrence relationship in the knowledge base; 
     FIG. 20 is an explanatory diagram of the taxonym relationship in the knowledge base; 
     FIG. 21 is an explanatory diagram of the co-occurrence relationship between a path and a sentence; 
     FIG. 22 is an explanatory diagram of a dependency structure of context data; and 
     FIG. 23 is an explanatory diagram of a path in the context data. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     A block diagram of a system in accordance with the present invention is shown in FIG. 1, which diagram will be used to explain the constituent elements of the system. The example given is in English; however, the system is not limited to use with any specific language. 
     Syntactic Analyzer 
     To begin with, a syntactic analyzer 10 or passer receives a sentence and outputs a syntactic structure involving ambiguities. The sentence, four example, &#34;VM/SP keeps the information on the virtual disk&#34;, is syntactically analyzed into a phrase structure involving attachment ambiguities, as shown in FIG. 2. Syntactic analysis technology is known in the art and is not involved as such in the present invention, so that a detailed description of the internal operation of the analyzer will not be presented here. It will be understood that the invention is essentially directed to dealing with the output of such devices. 
     Dependency Analyzer 
     The syntactic structure output is received by a dependency analyzer 20 which analyzes dependency structure and contains: 
     (1) a dependency structure builder 21; 
     (2) a dependency extractor 22; 
     (3) a dependency selector 23; and 
     (4) a dependency structure transformer 24. 
     In the dependency structure builder 21 a phrase structure is converted into a dependency structure explicitly indicating dependencies between words, as shown in FIG. 3. The phrase structure attachment ambiguities are expressed as ambiguities in dependencies among words. The dependencies are provided with labels corresponding to semantic cases. These labels are determined by referring to the grammatical word sequence and prepositions, and are expressed as a candidate list of possible semantic cases. 
     Ambiguous dependencies are extracted by the dependency extractor 22 from the created dependency structure as shown in FIG. 4. They are expressed as multiple possible candidate dependencies for one ambiguity. 
     In the dependency selector 23, relationships corresponding to the possible candidate dependencies are searched for in a background knowledge database 30, which contains knowledge expressed in the form of tree structures indicative of synonym relationships, taxonym relationships, and dependencies among words. When relationships are found for two or more candidates, the most preferable relationship is determined by using constraint conditions as will be explained below. 
     The dependency structure transformer 24 takes the most likely dependency for each ambiguity selected and accordingly transforms the dependency structure to resolve the structural ambiguity. In this case, the semantic case attached to the dependency is also determined uniquely. Thus, the output of the dependency analyzer 20 is the dependency structure of a sentence in which every ambiguity has been resolved. This output may then be provided to a utilization device 40 such as a system for natural language application, e.g., a machine translation. Further, knowledge bootstrapping may be accomplished by adding this output to the knowledge base 30. 
     Knowledge Base 
     As the determined dependency may be used as a constraint for analysis of subsequent sentences, it is therefore registered in the knowledge base 30 as context dependency data. Two features or characteristics of the system of the invention are a semi-automatically built knowledge base and a mechanism for selecting the best dependency by using the knowledge base. These will now be explained. 
     Construction of a Knowledge Base 
     The knowledge base 30 is initially constructed from collected information concerning words, such as terminology commentary. The system of the invention extracts semantic relationships between a certain word and another word, namely, synonym relationships, taxonym relationships, and dependencies. These relationships form a portion 31 of the knowledge base 30. The system expresses an item of knowledge in the form of a tree structure, for the reasons that: 
     (1) the tree structure can be made semi-automatically by analyzing a sentence; and 
     (2) it is suitable for expressing taxonym relationships and dependencies. (A synonym relationship may be converted into two taxonym relationships, as will be explained later.) 
     A further reason is that: 
     (3) inference for dependency structure analysis is basically a process of traversing up a branch of a tree structure. The knowledge base 30 contains tree structures indicative of dependency structures obtained from sentence and taxonym relationships obtained by converting the dependency structures. In other words, base 30 is a group of tree structures. 
     In conventional natural language processing systems, in which the necessary information for sentence analysis is not formalized, frames or other means capable of expressing substantially anything have been used successfully. However, such frame expressions are difficult to construct systematically, and largely rely upon human effort. Therefore, increasing the scale of the knowledge base is very laborious. 
     The knowledge base 30 of the present system can be built in a bottom-up manner; this makes it easy to increase the scale, and also corresponds to the nature of the problem of structural ambiguities. Naturally, knowledge must be acquired beforehand by learning (learned data). The data in the knowledge base are generated by analyzing commentaries on words, creating dependency structures, and then converting them. The preferred process will now be described. 
     (1) The syntactic analyzer 10 creates phase structures from an incoming sentence, and provides them to dependency analyzer 20 which converts them into dependency structures that define attachment relationships among words. In the learning step, a person determines ambiguous attachment relationships, and specifies a structure. For example, from the sentence, &#34;Operating system stores files on the disk&#34;, the phrase structure shown in FIG. 5 is created. It is then input to the dependency analyzer 20 where it is converted into the dependency structure with ambiguity shown in FIG. 6. This conversion is done by the dependency structure builder 21 of the dependency structure analyzer 20. 
     (2) As shown in FIG. 7, semantic case labels (agent, patient, location) are attached as attributes to the links indicating dependencies among words. Attachment of the labels behaves as a constraint condition for use in disambiguation. These labels are unambiguously determined by a person in the learning step after their candidates have been attached by the dependency structure builder 21. 
     (3) The dependency structure, resulting from sentences containing a taxonym (hypernym/hyponym) relationship and a synonym relationship between words such as &#34;A is a B&#34;, &#34;A is a synonym for B&#34;, and so on, is converted into a structure in which A and B are connected by a link labeled with &#34;isa&#34;. This structure is called an &#34;isa tree&#34;, and examples are shown in FIGS. 8 and 9. These dependencies will be stored in portion 31 of knowledge base 30. 
     Selection of the Most Preferable Dependency 
     In order to select the most preferable dependency, the system employs an improved method involving (1) searching paths corresponding to respective dependencies (path search) in the knowledge base 30, and (2) calculating values, called &#34;dependency distances&#34; for respective paths, on the basis of constraint conditions (distance calculation). The system then selects the dependency corresponding to the path having the shortest dependency distance as the most preferable dependency. This is done by the dependency selector 23 of the dependency structure analyzer 20. 
     The path search first limits the search space in the enormous amount of knowledge by using co-occurrence between words. The probability of occurrence of a single word in a natural language is very small, and thus very little knowledge is needed for two words actually co-occurring. As a result, those words subject to distance calculation, which create the heaviest calculating load, are very few. This results in a very efficient search. The path search and the distance calculation in accordance with the invention will now be described. 
     Path Search 
     A path between two words incorporates chains of synonyms and hypernyms starting from them and at least one dependency between the words at the ends of the chains. In other words, a path is a route between words if a knowledge base is regarded as a graph with words at its nodes. For example, a graph of the path between the words &#34;keep&#34; and &#34;virtual disk&#34; is shown in FIG. 10. The following algorithm has been developed in order to search for paths in a knowledge base. It uses an index table, such as shown in appended Table 2. In that table, the symbol tx denotes a pointer of a tree in which the word in the left-hand column appears, and values in parentheses indicate the node location of the word in the tree (see FIG. 11). The values shown are selected randomly by way of example and the center and right-hand columns of the Table represent the &#34;isa&#34; relationships of the words a, b, c, and d, and their &#34;dependency&#34; structures as indicated. 
     Labels are always affixed to &#34;isa&#34; or other branches as attributes of hyponym nodes. Therefore, the pointers tx in the column of &#34;isa trees&#34; indicate trees in which the corresponding word appears at a lower level of the &#34;ias&#34; branch. Accordingly, it is noted from the table (Table 2) that word a is located in position (0) of the &#34;ias&#34; tree of pointel t0. A search of the contents of the trees in the knowledge base 30 for the parent node reveals, for example, that word b is located in position () of the same tree that contains pointer t0, as shown in FIG. 12. Similarly, it will be seen from the &#34;isa trees&#34; column in Table 2 that other words which have relationships with the word a will be found in the parent nodes of t10(0) and t22(0). 
     It is found, then, by traversing up the tree by one node from t0(0) that word b is a synonym or hypernym for word a. By similarly reviewing the &#34;isa trees&#34; column of Table 2 for word b, all the words linked to word a by the &#34;ias&#34; labeled branches are found. By traversing up the &#34;ias&#34; tree by one node, the synonym or hypernym of word b is found. As a result, synonym or hypernym chains for word a can be created. 
     Assume here, for example, that P is a hypernym for Q, and that Q is a hypernym for R. In this case, two &#34;ias&#34; trees are created. In the present invention in order to know the hypernym for R, when R is entered into the table, one of the &#34;ias&#34; trees is used to find the direct hypernym Q for R, and the other &#34;ias&#34; tree is subsequently used to find the direct hypernym P for Q, and thereby to find all the hypernyms for R. 
     Thus, a synonym relationship between P and R may be converted into two taxonym relationships using their synonym Q, as mentioned above. First this example, the &#34;ias&#34; trees include just two words: the hypernym and the hyponym. In such case, it should be understood that the identification (ID) data for the &#34;ias&#34; trees containing incoming words as hyponyms is important, but that information on the location of the hyponyms in the trees is not indispensable. 
     In other examples, a single &#34;ias&#34; tree may contain the foregoing P, Q, and R. In that case, it is noted that not only the ID data of an &#34;ias&#34; tree containing a word should be entered into the table as a hyponym, but that information on the location of the hyponym in the tree is also indispensable. 
     Subsequently, in order to search for a path between two words, it is necessary to check whether any dependency is present between the words, one of which appears in one synonym/hypernym chain and the other of which appeals in another chain. This involves checking to determine whether a set of dependency trees, containing a word located in one of the chains, and a set of dependency trees, containing a word located in the other chain, have a common dependency tree, and whether any dependency or any dependency transition exists between the two words in that tree. In the dependency trees, the node locations of the two words in the trees are used to check whether any dependency between words or any transition between them exists. Here, when a first word modifies a second word indirectly through a third word, a transition of dependency exists between the first and the second words. 
     For example, referring to Table 2, a check may be conducted for a dependency in which word d modifies word b. It will be seen that the position (0) of b and the position (010) of d in a common node element t110, between a set of dependency structure trees {t30(1), t110(0)} containing b and a set of dependency structure trees {t40(10), t110(010)} containing d, reveals that b is an ancestor of d. In other words, this reveals that a transition of dependency exists between b and d (see FIG. 13). 
     In the tree structure, when the node of word a is an ancestor of the node of word b, the execute from b to a is determined uniquely. Therefore, discovery of a dependency is deemed to be equivalent to checking a positional relationship. The presence or absence of a path between words can be found by (1) using the &#34;ias&#34; trees to obtain all their synonym/hypernym chains, (2) then obtaining a node element included commonly in sets of dependency structure trees containing the words appearing in the chains, and (3) subsequently inspecting the positional relationship of the words in the trees. The path is obtained by tracing the trees containing the dependency. For example, one path between words a and c is shown in FIG. 14. 
     Dependency Distance Calculation 
     Several constraint conditions are possible for paths, and the closeness of dependency between words can be computed according to these conditions. The degree of closeness of dependency is called the &#34;dependency distance&#34;. This is calculated according to the number of branches (dependencies) contained in the path and the values obtained as a result of evaluation of the constraints. 
     Constraint conditions are classifiable into three categories. 
     (1) The first is &#34;case consistency&#34;, i.e., the condition constraint as to whether a semantic case label attached to a branch of a dependency in a path corresponds to a possible relationship in a candidate attachment, i.e., whether a certain word depends on a certain predicate as a subject or an object, and so on. For example, assume that the path shown in FIG. 16 has been obtained for the dependency shown in FIG. 15 of the sentence, &#34;VM/SP keeps the information on the virtual disk.&#34; The grammatical case (a case directly obtained from the sentence) between &#34;keep&#34; and &#34;virtual disk&#34; must then be consistent with the semantic case between &#34;store&#34; and &#34;disk.&#34; Here, the case consistency between the dependency and the path holds, since the grammatical case &#34;on&#34; can have the semantic case &#34;location&#34; indicative of a location. If this case consistency holds between the dependency and the path, then the value of case consistency of the path is 1; otherwise, it is 0. In this example, the value of case consistency of the path is 1. 
     (2) The second category of constraint conditions is &#34;co-occurrence consistency&#34;, which is a constraint regarding the relationship between words co-occurring in the same sentence. For example, when a certain word depends on a certain predicate as an object, then, for instance, the subject of the predicate should be a specific word or its synonym,/hypernym. 
     In the sentence of the foregoing example, &#34;VM/SP&#34; is the subject of &#34;keep&#34;, as shown in FIG. 17. In contrast, assuming that the path has been obtained from a dependency structure tree in the knowledge base as shown in FIG. 18, co-occurrence is found as shown in FIG. 19, and it is also found that &#34;operating system&#34; is an agent of &#34;store.&#34; Further, if a taxonym relationship between &#34;VM/SP&#34; and &#34;operating system&#34; as shown in FIG. 20 is defined as the knowledge, it is found that the co-occurrence consistency of words holds between the path and the sentence, as shown in FIG. 21. Here, since the grammatical case &#34;subject&#34; can have the semantic case &#34;agent,&#34; case consistency also holds. In this fashion, the number of co-occurrence consistencies (concurrent consistencies of words and cases) is the value of the co-occurrence consistency. In this example, the value of the co-occurrence consistency of the path is 1 (it is assumed that co-occurrence consistency for cases other than the subject does not hold). 
     (3) The third category of constraint conditions is &#34;context consistency&#34;. If dependencies between words appearing in a path already exist in previous sentences, the dependencies are considered to be firmly supported by the context, and the dependency distance on the path becomes close. 
     For example, if the sentence, &#34;In VM/SP, the data is stored in the storage device.&#34;, comes before the above sentence, &#34;VM/SP keeps the information on the virtual disk.&#34;, then the dependency structure shown in FIG. 22 is stored as the context data (32) of the knowledge base 30 (the &#34;object&#34; referred to therein is not a semantic case but a grammatical case indicative of an object). If a path is sought between &#34;store&#34; and &#34;disk&#34; of the dependency &#34;store←disk&#34; appearing in the path of FIG. 16, using synonym/taxonym relationships and context dependencies of the knowledge base 30, then the path shown in FIG. 23 is found, and it is found that the dependency between &#34;store&#34; and &#34;disk&#34; is defined in the context. Thus the number of dependencies contained in the path and defined in the context is the value of context consistency. In this example, since one dependency is contained in the path and defined in the context, the value of context consistency of the path is 1. 
     The value of &#34;dependency distance&#34; is calculated by using the values of the foregoing constraints and the number of dependencies contained in the path. More specifically, it is computed from the following formula: ##EQU1## This formula assumes that case and co-occurrence consistency affect the entire path, but that context consistency affects each dependency included in the path. Here, n is a real number in the range 0&lt;n&lt;1, and is an heuristic parameter that represents the degree of unimportance of the context. The dependency distance in the above example is 0.125 because the number of dependencies is 1, the value of case consistency is 1, that of co-occurrence consistency is 1, and that of context consistency is 1 (n is defined as 0.5). 
     Registration in Knowledge Base 
     The dependency structure that has been determined to be most preferable by the selector 23 is output by the dependency analyzer 20 and registered in the knowledge base 30 where it is used for structural disambiguation of subsequently input data. Since the .result of the decision greatly depends on the context, it is preferable to register the result independently as context dependency data in portion 32 in order to distinguish it from learned data in portion 31 (see FIG. 1). More specifically, the knowledge base 30 stores information on the dependency structure and the semantic case, as shown in FIG. 7, in portion 31, and the index table in the right hand column of Table 2 is prepared for context dependency data for each field, in portion 32. When the most preferable dependency has been selected in selector 23 of analyzer 20, corresponding data is added to the knowledge base 30 including the index table in context dependency data portion 32. Duplicate registration may be prevented by referring to a previously registered dependency. 
     In this fashion, knowledge can be increased automatically in the knowledge base 30. Thus, while in a strict sense the method is not fully automatic since human intervention is needed in some operations, still, knowledge is developed in the system at least semi-automatically. 
     Practical Examples ##STR1## Experiment Results 
     The ability of the present system to resolve prepositional attachment ambiguities, has been tested by using approximately 2,000 sentences, extracted from a computer manual. The result is shown below. The knowledge used here consists of the dependency structures extracted from about 20,000 definition sentences in the &#34;IBM Dictionary of Computing&#34;. 
     
         ______________________________________Total number of          Number of attachments correctlyprepositional phrases          disambiguated by the system______________________________________4290           3569Success ratio  4290/3569 × 100 = 83.2%______________________________________ 
    
     The results show that the system is significantly effective. 
     This invention enables a large-scale knowledge database for resolution of structural ambiguities in natural language to be constructed and used efficiently. 
     
                       TABLE 1______________________________________Examples of semantic caseSemantic case    Role______________________________________Agent    Person who causes a certain actionPatient  Person who experiences a certain eventInstrument    Cause of a certain event, or stimulation causing a    certain reactionObject   Object to be moved, object to be changed, and    contents of consideration or other    psychological movementSource   Starting point for movement of an object,    initial aspect of a change in a stateTarget   Terminal point for movement of an object,    terminal aspect of a change in a stateLocation Location and position of a certain eventTime     Time at which a certain event occurs______________________________________ 
    
     
                       TABLE 2______________________________________Index tableWords  isa trees         dependency trees______________________________________a      t0 (0)  t10 (0) t22 (0) t101 (0 1)                                 t150 (1 0)b      t5 (1)  t52 (0) t62 (0) t30 (1)                                 t110 (0)c      t2 (0)  t15 (0) t72 (1) t101 (1 1)                                 t350 (0 2 3)d      t8 (1)  t25 (1) t82 (0) t40 (1 0)                                 t110 (0 1 0). . .  . . .             . . .______________________________________