Abstract:
In response to the users actions relative to graphical representations of a multiple inheritance concept hierarchy to delete, add or modify the relationships between the various concepts, property declaration, property constraints and relationships therebetween, this system first, recognizes and disambiguates possible semantic incoherance introduced by the changes; second, suggests alternative procedures to ameliorate any perceived incoherence; third, interactively allows an agent (user or machine) to select from one of the alternatives; and fourth, performs the sequence of necessary operations to resolve semantic incoherence in the modified hierarchy.

Description:
RELATED PATENT APPLICATIONS 
     1. U.S. patent application Ser. No. 08/472,414 filed on Jun. 7, 1995 and entitled &#34;Method and Apparatus for Representing Knowledged About Entities&#34;, abandoned. The contents of the above identified application are hereby incorporated herein by reference. 
     2. U.S. patent application Ser. No. 08/977,092 filed on even date herewith and entitled &#34;A Method and Apparatus for Navigating Multiple Inheritance Concept Hierarchies&#34;, pending. The contents of the above identified application are hereby incorporated herein by reference. 
     3. U.S. patent application Ser. No. 08/688,350 filed on Jul. 30, 1996 and entitled &#34;Enhanced Tree Control System for Navigating Lattices Data Structure &amp; Displaying Configurable Lattice Node Labels&#34;, pending. The contents of the above identified application are hereby incorporated herein by reference. 
     4. U.S. patent application Ser. No. 08/725,961 filed on Oct. 7, 1997 and entitled &#34;Enhancing Feature Based Search Through Feature Relevance Reasoning&#34;, allowed. The contents of the above identified application are hereby incorporated herein by reference. 
    
    
     TECHNICAL FIELD 
     The present invention relates to a method and apparatus for modifying databases. More particularly, it relates to a computer automated method for modification of the contents of a multiple inheritance concept hierarchy database. 
     BACKGROUND 
     A hierarchy is a common method for organizing information. The table of contents for a book, an index system for a library and a function chart for a company&#39;s departments are examples of hierarchical arrangements of information. A hierarchy comprises nodes and their interrelationships. When a hierarchy interrelates structured nodes, those nodes are commonly called concepts (other terms used for nodes include scenes, frames, individuals and classes). The structure of a concept is described by the use of characteristics called properties. 
     The meaning given to these concepts and their hierarchical interrelationships depends on the real world domain that is being represented by the data hierarchy or structure. Structures comprising concepts and their interrelationships are commonly known as &#34;part-of&#34; decomposition hierarchies arid &#34;is-a&#34; abstraction hierarchies. 
     A &#34;part-of&#34; decomposition hierarchy is typically found in corporation departmental organization charts. Each sub-department is part-of a super-department. For example, the Electronic Catalog Division and Electronic Transaction Division are part-of the Electronic Commerce Division. The Electronic Commerce Division and Information Distribution Division are part-of the Internet Division which is in turn part-of the Software Division. 
     An &#34;is-a&#34; abstraction hierarchy is typically found in biological animal and organism classification charts. Each sub-abstraction is-a more specific (specialized) description of a super-abstraction. For example, the family of lions and the family of tigers are more specific descriptions of the family of large cats. The family of large cats and the family of humans are more specific descriptions of the family of mammals. The sub-concepts in these hierarchies usually share common properties with their super-concepts. We take advantage of this fact and minimize the amount of data we need to store by only defining common properties in a super-concept and allow sub-concepts of the super concept to &#34;inherit&#34; (access, use) these properties as part of their own definitions. Hierarchies with this characteristic are termed inheritance hierarchies. When a sub-concept can interrelate to only one super-concept, the hierarchy is termed a single inheritance concept hierarchy, and when a sub-concept can interrelate to more than one super-concept, the hierarchy is termed a multiple inheritance concept hierarchy. An example of a multiple inheritance concept hierarchy is found in the above mentioned U.S. application, Ser. No. 08/472,414, abandoned. 
     A way of visualizing these hierarchical data structures is by using a tree view as shown in FIG. 1. One method for visualizing any structured node in the tree view of FIG. 1, in combination with that node&#39;s properties, would be to use a concept view as shown in FIG. 2. The example given in FIG. 2 is for the &#34;Mobile&#34; structured concept 101 of FIG. 1. 
     With these two views, a user can navigate the concept hierarchy shown in FIG. 1 by starting at the root concepts &#34;Company&#34; or &#34;Function&#34; and continue thru the sub-concepts until the leaf concepts are reached. At each concept, a concept view, such as the one of FIG. 2, can be consulted for a detailed examination of the structure of the concept. Switching back and forth between hierarchial and concept type views is a popular method of investigating concept hierarchies. 
     The data structure shown in FIGS. 1 and 2 is created and maintained by either a human agent using a Graphic User Interface (GUI) (e.g. an information architect) or a computer agent (a software program acting on behalf of a human). A human or agent incrementally creates the data structure, representing some domain in the real world, by first adding base concepts and their property definitions. Ideally, this creation process would continue until the entire data structure is created and the whole domain is succinctly represented. In reality, however, the process of realizing a final data structure is one of continual revision and refinement. There is a continual cyclical process of creation and modification as new concepts are introduced and old ones modified. 
     The problem is that it is time intensive to manually recover the semantics of the hierarchy when modifying a concept&#39;s properties or interrelationships. This time expense is measured in human hours when a human is modifying the data structure and machine hours when a program is performing the modification. In both cases, the most expensive operations are those modifications done at the top of the hierarchy as it often affects all of the other sub-concepts in the hierarchy. 
     Modification is expensive because of the nature of hierarchical data structures with inheritance. Many of the concepts and their properties are highly interrelated and non-localized. The creation of the hierarchy is a process of building increasing complex data structures upon previously created data structures. Until now, humans and computers have had to manually reverse the creation process to effectively reset the data structure to the state it was in prior to the creation of the data structure to be modified. Often this process is so expensive and arduous that it is easier to recreate the structure than undo the creation process, make the modification and then recreate what was just undone. 
     BRIEF DESCRIPTION OF THE INVENTION 
     In accordance with the present invention, the problem of modification of the data structure is solved by providing a computer automated method for interactively maintaining the semantics of concept hierarchies when concept properties and concept interrelationships are modified. In response to the users actions relative to graphical representations of the hierarchy, such as those of FIGS. 1 and 2, to delete, add or modify the relationships between the various concepts, property declarations, property constraints and relationships therebetween, the present invention first recognizes and disambiguates possible semantic incoherence introduced by the changes, second, suggests alternative procedures to ameliorate any perceived incoherence, third, interactively allows an agent (user or machine) to select from one of the alternatives, and fourth, performs the sequence of necessary operations to resolve semantic incoherence in the modified hierarchy. 
     Therefore, it is an object of the present invention to provide a computer directed method for interactively modifying multiple inheritance concept hierarchies. 
     It is another object of the present invention to maintain semantic coherence when modifying multiple inheritance concept hierarchies. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     These and other objects, features and advantages of the invention can best be understood by reference to the following detailed description while making reference to the accompanying drawings of which: 
     FIG. 1 is a computer screen presentation showing a hierarchial view of the concepts in a database; 
     FIG. 2 is a computer screen presentation showing the properties of one of the concepts shown in FIG. 1; 
     FIG. 3 is a graphical representation of a multiple inheritance concept hierarchy to which the present invention applies; 
     FIGS. 4 to 21 are flow diagrams of the functioning of a computer in accordance with the present invention; 
     FIG. 22 is a logic block diagram indicating the functioning of a computer in accordance with the present invention; 
     FIG. 23 is a block diagram of a computer system containing the present invention; 
     FIG. 24 is a block diagram of a data base system to which the present invention applies; 
     FIGS. 25 and 26 are query screens produced in connection with a drag and drop operation performed on the screen of FIG. 1; and 
     FIG. 27 is a query screen produced in response to an action taken in connection with FIG. 2. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     In FIG. 3, the concepts &#34;Function&#34; and &#34;company&#34; are termed &#34;root&#34; concepts (they have no super-concepts) and concepts &#34;Notebook&#34;, &#34;Tablet&#34;, &#34;Desktop&#34;, &#34;Hard Disk&#34; and &#34;CD Drive&#34; are termed &#34;leaf&#34; concepts (they have no sub-concepts). The concept &#34;Hard Disk&#34; inherits properties from both the concepts &#34;Component&#34; and &#34;IBM&#34;. Properties that have been inherited by a sub-concept from a super-concept are termed &#34;inherited properties&#34; of the sub-concept. Those that are declared within a concept are termed &#34;local properties&#34; of the concept. 
     In making a change in the structure of a hierarchy, the effect the changed portion has on the remainder of the hierarchy must be taken into account. For instance in FIG. 3, assume the concept &#34;Mobile&#34; is to be eliminated, the declaration of &#34;Battery Life&#34; and the constraint of &#34;Black&#34; for the declaration &#34;Color&#34;. If &#34;Desktop&#34; computers are to be black rather than white, this constraint could be moved to the concept &#34;Computer&#34; since the restriction would apply equally well to &#34;Notebook&#34;, &#34;Tablet&#34; and &#34;Desktop&#34; computers. Otherwise, the constraint must be listed in both the &#34;Notebook&#34; and &#34;Tablet&#34; concepts. Since &#34;Battery Life&#34; does not apply to &#34;Desktop&#34;, that declaration must be dropped to the leaf concepts of &#34;Notebook&#34; and &#34;Tablet&#34;. 
     Therefore, it is understood that rules used to establish the hierarchy must be followed when portions of the hierarchy is changed, deleted or added to. These rules are first checked when concepts, concept interrelationships and properties are created. The rules must then be enforced when modifying the data structure. The rules are: 
     1. The graph formed by the concept hierarchical interrelationships must not contain cycles, For example, in FIG. 1, we could not have &#34;Mobile&#34; as a sub-concept of &#34;Computer&#34; and &#34;Computer&#34; a sub-concept of &#34;Mobile&#34;. 
     2. A super-concept must always exist if it ha; interrelated sub-concepts. For example, in FIG. 1, the concept &#34;Computer&#34; must always exist if the concepts &#34;Mobile&#34; and &#34;Desktop&#34; are its sub-concepts. 
     3. The type of a property must always exist. For example, in FIG. 1, the property &#34;Fixed Disk (Hard Disk) always relies on the existence of the concept &#34;Hard Disk&#34;. The concept &#34;Hard Disk&#34; cannot be removed if there are properties that depend on its existence as a type of a property. 
     4. A property must always exist if there is a constraint that constrains the property. For example, in FIG. 1, the &#34;Form Factor&#34; property declaration in concept &#34;Computer&#34; must always exist while the constrains &#34;Form Factor=Notebook&#34; and &#34;Form Factor=Tablet&#34; depend on its existence. 
     5. A property can only be constrained at a concept if the property declaration is accessible at that concept i.e., the property is either declared in the same concept as the constraint or the property can be inherited for some super-concept in its lineage. For example, in FIG. 1, the property &#34;Battery Life&#34; in concept &#34;Mobile&#34; cannot be constrained in the concept &#34;Desktop&#34;. The property declaration is not accessible to the concept &#34;Desktop&#34;. The property can, however, be constrained at both the concept &#34;Mobile&#34; and the concepts &#34;Notebook&#34; and &#34;tablet&#34;. 
     6. No two properties can have the same name in the same concept. For example, in FIG. 1, it is not possible to declare another property &#34;Form Factor (integer)&#34; in concept &#34;Computer&#34;. 
     In accordance with the present invention, modification of multiple inheritance concept hierarchies are justified in response to the users actions with respect to FIGS. 1 and 2 using the word processing, and mouse drag-and-drop facilities common to all operating systems that support graphical user interfaces. The following concept interrelationship modifications can be performed: 
     1. Drag a concept leaf or intermediate concept to an intermediate concept target for Insertion. The user drags a concept to another Concept. The intent is for the source concept to KEEP its current parents and add another one by INSERTING itself between the target concept and its children (sub-concepts). 
     2. Drag a leaf or intermediate concept to a leaf concept or intermediate concept target. The user drags a concept to another concept. The intent is for the source concept to LOSE one or more of its current parents and then add one additional new parent by APPENDING the source to the target concept. The user does not wish the source to retain any attributes or information from its removed parentage. 
     3. Drag a leaf or intermediate concept to an intermediate concept target. The user drags a concept to another concept. The intent is for the source concept to LOSE one or more of its current parents and then add one additional new parent by INSERTING the source between the target concept and its children (if it has any). The user does not wish the source to retain any properties from its removed parentage. 
     4. Drag a leaf or intermediate concept to an intermediate concept target. The user drags a concept to another concept. The intent is for the source concept to LOSE one or more of its current parents and then add one additional new parent by making the source an additional child of the target concept. The user does wish the source to retain property declarations or constraints from its original parentage. 
     5. Drag a leaf or intermediate concept to an intermediate concept target. The user drags a concept to another concept. The intent is for the source concept to LOSE one or more of its current parents and then add one additional new parent by INSERTING the source between the target concept and its children (if it has any). The user does wish the source to retain any property declarations or constraints from its parentage. 
     Concept Deletion and Extraction Includes: 
     1. Delete target is a single leaf concept. The user wishes to remove a concept from the hierarchy that has no children inheriting from it. This action deletes all constraints, then local property declarations in a concept and finally deletes the concept itself. 
     2. Delete target is a single intermediate concept. The user wishes to remove a concept from the hierarchy including any children inheriting from it. This action deletes all constraints, then local property declarations in all descendants of a concept, deletes the descendants and finally does the same for the concept itself. Also, any properties in the hierarchy that describe a relationship to the target or any of its children are deleted. This case is basically deleting a branch or branches of the hierarchy. 
     3. Delete target is a single intermediate concept. The user wishes to extract a concept from the hierarchy and re-parent its children. This action deletes all constraints, then local property declarations in a concept and then deletes the concept itself. Also, any properties in the hierarchy that describe a relationship to the target are deleted. If the target concept has multiple parents, its children are re-parented to the parent directly connected to the target in the Catalog view. This case is extracting a concept from a branch. 
     Concept Property Deletion and Modification Includes: 
     1. Delete a property declaration including all its constraints in descendants. This action deletes all the property constraints in a concept and any of its descendants. Then the property declaration itself is deleted. 
     2. Promote a property declaration into an ancestor keeping all constraints. This feature allows the user to take an existing property declared in a concept and change the owner of the declaration to an ancestor up the hierarchy while preserving any existing constraints down the hierarchy. 
     3. Promote a constraint into an ancestor. This feature allows a user to take an existing constraint declared in a concept and change the owner of the constraint to an ancestor up the hierarchy. 
     4. Demote a property declaration into a descendent concept keeping all constraints. This feature allows the user to take an existing property declared in a concept and change the owner of the declaration to one or more of its descendants down the hierarchy while preserving any existing constraints down the hierarchy. Any constraints that no longer have access to the property declaration are deleted. 
     5. Demote a constraint to a descendent. This feature allows the user to take an existing constraint declared in a concept and change the owner of the declaration to one or more of its descendent down the hierarchy. 
     6. Promote a property across all siblings into a common ancestor keeping all constraints. This feature allows the user to take an existing property declared in a set of sibling concepts and change the owner of the declaration to a common ancestor up the hierarchy while preserving any existing constraints that may exist in the sibling concepts and their descendants. This is a macro operation on the micro operation described in 2. 
     7. Promote a constraint across siblings into a common ancestor. This feature allows a user to take a constraint that exists in several sibling concepts and move the constraint to a common ancestor. This is a macro operation on the micro operation described in 3. (Both 7 and 8 involve doing a search across the siblings for common property and constraint names or values and then applying the micro operations already described.) 
     The methodology used by the software for interactively maintaining the semantics of concept hierarchies when performing concept deletion, is shown in FIGS. 4 through 21. These figures provide an incrementally more complicated procedure for maintaining concept hierarchies. For instance, FIG. 21 builds on the method displayed in earlier figures to provide the method for recognizing and disambiguating possible semantic incoherence introduced by permitting simple drag and drop (or cut/copy and paste) operations to be used for modifying concept hierarchies. 
     The operation is an interactive one where some of the steps shown in FIGS. 4 to 21 are performed by the computer, while the remaining steps are performed by the user in response to interrogations by the computer. Referring to FIG. 1, a drag and drop operation or a concept extraction operation would produce query screens of FIGS. 26 and 27 in the display asking the user as to the action to be taken. For instance, those who wish to eliminate XYZ Corporation as a parent for CD drive and make IBM the parent for the drive. The first query screen (FIG. 25) queries the user as to whether CD Drive is to be copied to or moved to the new parent, in addition the user may specify that concepts having a dependency on the operation to be performed are shown. The second query screen (FIG. 26) queries the user as to whether the CD Drive is to be added to the IBM concept as a child or inserted between the IBM and Hard Disk concepts, making CD Drive a child of IBM but a parent of Hard Disk. 
     Similarly, if the user deleted the declaration of the property &#34;Color&#34; in the &#34;Computer&#34; concept shown in FIG. 2, the query box shown in FIG. 27 would appear, requesting that the user inform the computer if color=black and color=white in &#34;Mobile&#34; and &#34;Desktop&#34; are to be removed or moved to a sub-concept. The &#34;Move&#34; option in FIG. 27 produces the two selections in space 2710, either or both can be selected. 
     As pointed out above, FIGS. 4 to 21 show various actions taken by the computer in response to actions taken by the user. Certain of the figures contain titles for steps that reflect the title of other figures. In such cases, the steps containing such titles include the steps of the other figure. Referring to FIGS. 4 and 5, the removal of a property declaration by the user, results in destruction by the computer of constraints on the property declaration 401. Firstly, by destroying 402 all local constraints on that declaration and secondly, by destroying 403 the constraints for each sub-concept of that concept having the declaration. For example, removing the property &#34;Battery Life&#34; in the &#34;Mobile&#34; concept of FIG. 3 results in removal batt life=2.0 and batt life=2.5 of the &#34;Notebook&#34; and &#34;Tablet&#34; concepts. This is done automatically by the computer. 
     FIG. 6 is a subroutine in FIGS. 10 and 11 for the user selecting a sub-concept 601 to attach to a concept. If there is only one sub-concept, the machine automatically attaches it to the concept. If there is more than one, the user is pointed through the space in a screen, such as the one in FIG. 26, to select a sub-concept, and then attaches the selected sub-concept. 
     FIG. 7 is a subroutine in FIGS. 8 and 9 where the user is selecting a super-concept 701. If there is only one super-concept, the computer will automatically couple it to the concept 702. However if there is more than one, the computer through a query space, such as the one in FIG. 26, prompts the user to select the proper super-concept after which it automatically connects that super-concept up to the concept. 
     FIG. 8 is where the user elects to promote a property declaration from a concept to a super-concept. After a user selection of the super-concept 802, the computer checks to see if this results in a name conflict 803, and if it does not, moves the declaration to the super-concept 804. If there is a conflict, the user is asked if the declarations can be merged 805. If they cannot, the process fails 806. If the properties can be merged, the property declaration to be moved is deleted 807, and its constraints are moved to the property declaration of the super-concept 808. 
     FIG. 9 shows action of the computer in response to promotion of a constraint 901. An example of this, would be to promote the constraint &#34;Black&#34; for the declaration &#34;Color&#34; in the concept &#34;Mobile&#34; to the concept &#34;Computer&#34;. If such a move were to be made, not only &#34;Mobile&#34; but &#34;Desktop&#34; computers would have to be black. Thus, if the computer decides that the property declaration is accessible 902, the restraint black is moved 903 to &#34;Computer&#34;. 
     When the user selects to demote a property declaration 1001, the computer reacts as shown in FIG. 10. If there is no property name conflict 1002 and the constraints are accessible 1003, the computer moves the property declaration to the sub-concept 1004. If the constraints are not accessible, the computer deletes the constraints 1005 prior to moving the property declaration 1004. If there is a name conflict, and merging is possible and decided upon by the user, the computer moves the properties constraints from the source concept to the sub-concept property declaration 1006, and deletes the selected property declaration 1007. An example of demoting a declaration would be to move the declaration &#34;Color&#34; from the concept &#34;Computer&#34; to the concept &#34;Mobile&#34;. Then the declaration &#34;Color&#34; and its constraint &#34;Black&#34; would both occur in the concept &#34;Mobile&#34;. The concept &#34;Desktop&#34; would then no longer have a color constraint. 
     FIG. 11 shows where a user elects to demote constraint 1101. An example of this would be to move the color &#34;Black&#34; from the concept &#34;Mobile&#34; to the leaf concept &#34;Notebook&#34;. Upon selection, the users selection of the sub-concept 1102, the constraint is moved 1103 leaving &#34;Tablet&#34; free of the constraint &#34;Black&#34;. 
     In FIG. 12, the user elects to delete a leaf concept 1201, such as &#34;Desktop&#34;. In response to that deletion, the computer promotes property declarations such as &#34;CD ROM&#34; to the &#34;Computer&#34; concept. 
     In FIG. 13, if the user selects to delete an intermediate concept 1301, the computer searches for sub-concepts and deletes them once all sub-concepts are destroyed it destroys the concept 1304. 
     FIG. 14, is a subroutine relying on other subroutines to delete a super-concept interrelationship. The computer promotes property declarations of constraints 1402 and 1403 to another super-concept relationship. Alternatively, if there is no such super-concept, delete those property declarations and constraints 1404 and 1405 and finally destroy the super-concept interrelationship 1406. For instance, if the concept &#34;Computer&#34; was to be deleted in the tree of FIG. 3, the declarations Form Factor&#34;, &#34;Color&#34; and Fixed Disk&#34; would be deleted rather than promoted to a higher super-concept. 
     FIG. 15 is a subroutine relying on other subroutines to delete a sub-concept relationship 1505. The system demotes property constraints and declarations 1502 and 1503, where applicable, but deletes inapplicable property declarations and constraints 1504 and 1506. Finally, it destroys the sub-concept relationship 1506. 
     FIG. 16 is a subroutine relying on other subroutines to be used where super-concept interrelationships are to be deleted 1601 without deleting the concept. Such a case can be seen in FIG. 3 where relationship of &#34;Tablet&#34; to &#34;Mobile&#34; would be terminated so that concept &#34;Tablet&#34; would depend directly from the concept &#34;Computer&#34;. 
     In FIG. 17, is a subroutine relying on other subroutines to be used where concept interrelationships are to be deleted. 
     In FIG. 18, the user wishes to delete a concept 1801. This would be illustrated by removing &#34;Mobile&#34; as a concept in FIG. 3. In so doing, the &#34;Notebook&#34; and &#34;Tablet&#34; concepts can get appended directly on &#34;Computer&#34; after all super-concept and sub-concepts to &#34;Mobile&#34; have been deleted 1802 and 1803. 
     FIG. 19 illustrates the situation where the user wishes to append a source concept to a target concept 1901. An example for that in FIG. 3 would be to append the CD drive concept to IBM concept. The computer checks to see if this causes a hierarchial cycle. If it determines that no hierarchial cycle exists 1902, it creates the relationship of IBM being super-concept for CD drive 1903, otherwise the process fails 1904. 
     In FIG. 20, the user elects to insert a source concept between the target concept and concept 2001. In FIG. 3 if the concept &#34;Mobile&#34; was not in existence, this process would involve insertion of the &#34;Mobile&#34; concept between target concept &#34;Computer&#34; and its sub-concepts &#34;Notebook&#34; and &#34;Tablet&#34;. The computer searches the hierarchy for a hierarchial cycle 2002, and if none exists, inserts the &#34;Mobile&#34; l concept by creating a super-concept interrelationship between &#34;Computer&#34; and &#34;Mobile&#34; and sub-concept interrelationship between &#34;Notebook.&#34;, &#34;Tablet&#34; and &#34;Mobile&#34; 2004. 
     In FIG. 21, the user elects to move a source concept to a target concept 2101. The computer examines the hierarchy for hierarchial cycles 2102 and if there is none created by the move, it queries the user if he wishes to delete any super-concept interrelationship 2103. If the answer is yes, he deletes the super-concepts interrelationships 2104. The computer then queries the user about deleting the sub-concept interrelationships 2105. If the answer again is yes, it deletes the sub-concept relationships 2106. The next query is whether to insert the source concept 2107. If the answer is no, it appends the source concept to the target concept 2108. If the answer is yes, it inserts the source concept between the target concepts and its sub-concepts 2109. 
     Referring now to FIG. 23, the system 2300 includes a computer display screen 2301 which interacts with the user 2302 through commands entered through user input device 2303 (such as a mouse and keyboard) to present the screens 2304 and 2305 shown in FIGS. 1 and 2, respectively. The displays are provided by a search engine 2307 in response to control signals inputted by the user 2302 through the user interface device 2303. A windowing system 2308, such as the Windows NT or 95 operating systems of Microsoft Corporation, acts as an intermediary between the search engine 2307 and the user input device 2303 and display 2301. The search engine 2307 includes the displays 2304 and 2305, a display server 2310 for populating the displays of FIGS. 1 and 2 with data including that placed in the query list space 104 and 202 when they are invoked. The display server 2310 receives data from the database 2311 serviced by the database engine 2312 through a hierarchial shell 2313, such as one provided in accordance with the above mentioned U.S. patent application 08/472,414 (Applicants&#39; docket number CT9-95-002). 
     Though a software embodiment is provided in the present embodiment certain of the functions could be embodied in hardware. 
     The present invention is capable of running on any properly configured general purpose computer system, such as the one shown in FIG. 28. Such a computer system 2300 includes a processing unit (CPU) 2302 connected by a bus 2301 to a random access memory 304, a high density storage device 2308, a keyboard 2306, a display 310 and a mouse 312, such as Mouse Port Compatible Mouse 2.0A of the Microsoft Corporation. Also attached to the CPU 2302 by the bus 2301, are a scanner 2314 for scanning documents 2316 into the computer 2300; and CD-ROM and magnetic disc drivers 318 and 320 for entry of information from optical and floppy magnetic discs 2322 and 2324 containing program code and data. An example of such a computer is an IBM Personal Computer of the International Business Machines Corporation, such as an Aptiva L31 Model with a 233 MHz Pentium processor of Intel Corporation operating under Microsoft Windows 95 operating system of the Microsoft Corporation. 
     The computer 2300 also contains a modem 2326 for telecommunication of information 2328 on the Internet and other networks. Computers 2300, like the one described above, are connected together in a network by a server that can be used to exchange information and one computer can access information contained in another. The screens, the database and the search engine may be permanently located on all computers of the network, or one or all can be transmitted from one computer to another computer when the computer database is to be accessed. 
     As shown in FIG. 24, the data 2400 is stored in a database 2402, such as the DB2 Relational Database of International Business Machines Corporation. It is accessed through the database search engine 2403 and a multiple-inheritance concept hierarchy shell 2404 configured in the manner described in copending U.S. patent application Ser. No. 08/427,414 and entitled &#34;Method and Apparatus for Representing Knowledge About Entities&#34; (Applicants Docket No. CT9-95-002). The data 2400 in the database 2402 can be accessed from Windows 95 compatible graphical user interface on the display 2310 of FIG. 23 with screens provided in accordance with the present invention. 
     Above we have described an embodiment of the invention and modifications of the invention obvious to those skilled in the art, and therefore it is understood that the invention also covers embodiments within the spirit and scope of the appended claims.