KR20060016744A - System and method for storing and accessing data in an interlocking trees datastore - Google Patents

Abstract

A tree-based data store comprising a forest of interconnected trees is generated and/or accessed. The tree-based data store comprising a first tree that depends from a first root node and may include a plurality of branches. Each of the branches of the first tree ends in a leaf node (350). Each leaf node may represent an end product, or a subcomponent node. A second root of the same tree-based data store is linked to each leaf node representing an end product (356). Finally, the tree- based data store comprises a plurality of trees in which the root node of each of these trees can be described as an elemental node. The root node of each of these trees may be linked to one or more nodes in one or more branches of the first tree (9a). The nodes of the tree-based data store contain only pointers to other nodes in the tree-based data store, and may contain additional fields wherein one such may be a count field. Additionally, means to get probabilities of the coincidence of variables related to particular nodes as identified by desired contexts within one or more defined foci are described. Further, the application of logical operators to queries regarding such variables is shown.

Description

TECHNICAL AND METHOD FOR STORING AND ACCESSING DATA IN AN INTERLOCKING TREES DATASTORE}

This application is a CIP application of US Patent Application US-A 10 / 385,421, filed March 31, 2003.

The present invention relates to the field of arithmetic, and is an invention related to storing data in a data storage device and accessing data in the data storage device.

One basic option developers take in software development is to choose the right data structure to facilitate the organization and reference of the data. Many different kinds of data structures are available. For example, link lists, stacks, trees, arrays, and so on. Each data structure has some advantages and some limitations.

One frequently used data structure is a "tree". One common type of tree consists of a definite set of elements called todras, linked together from one root to another internal node. At this point, each node may be connected to one or more nodes, eventually ending in multiple leaf nodes. In general, a noir adjacent to a route is a parent node of nodes far away from the route. Nodes far from the root are called child nodes of the parent node. Data is typically stored at nodes, and can be referenced using links from root to node to leaf, and from parent node to child node. As a result, vertical / sequence relationships can contribute to the data stored in the nodes of the tree structure. Vertical relationships can be understood as contextual relationships. At this point, each node is accessible within the context of its parent node.

One limitation of tree data structures is that the tree can represent only one vertical structure. For example, a root node for sales activity has a number of nodes branching from the root node. In this instance, each node represents a particular seller. Each seller node may have a child node, and each seller child node, for example, represents a sale in a particular state. Thus, this tree can be easily accessed for main information within the seller's context. In other words, this tree can be used to efficiently answer the question, "Which state does Bob sell?" Instead of accessing the state data by the seller, if we need the seller data in the state context (that is, we want to answer the question: "What does the seller sell in Texas?), Another tree must be created The nodes represent states that diverge from the root seller activity, and child nodes representing the states can be diverted from them.An alternative way to create another tree is to traverse the entire tree in both directions to extract the desired information. will be.

It would be desirable if all possible contextual relationships within the data could be recorded in one structure, so that an efficiency that could not be realized with a standard tree data structure could be achieved.

A tree-based datastore containing one or more levels in the forest of interconnected trees is generated and accessed. Each level of the tree-based datastore includes a first tree branching from a first root node, wherein the first tree may include a number of branches. The first route may represent a concept such as a level begin indicator. Each branch of the first tree ends with a leaf node. Each leaf node may represent a final product. A second root of the same level of the tree-based datastore is connected to each leaf node of the first tree representing the final product. Thus, the second route is a subset of the first route, or a route to the reverse order of the first tree. However, the first tree is not duplicated. The second route may represent a concept such as a level end indicator. Finally, a tree-based datastore includes a number of trees, where the root node of each of these trees may contain data, such as dataset elements, or representations of dataset elements. This kind of root node is called an "elemental root node". The element root node may be linked to one or more nodes of one or more branches of the first tree that are not replicated. Non-root nodes of a tree-based database only have pointers to other nodes of the tree-based datastore. The roots of the trees in the forest of trees containing each level of the tree-based datastore are also composed of pointers, but this route may additionally carry data representing information. All other nodes in the tree-based datastore only point to other nodes and do not hold data. In one embodiment, the data corresponds to conditions such as integers, pixel representations, start indicators, end indicators, field indicator start, etc., associated with the character. Several levels of the tree-based datastore described above can be generated and accessed. The final product at the lower level becomes the element root node at the next level.

An interlocking tree datastore is generated and accessed. This datastore contains ascension branches forming one assortment tree branching from the first root (in other words "primary root"), and asreacting forming multiple assortment trees branching from multiple roots. It contains a multi-root tree composed of branches. One particular example of an Astree tree includes one root node that is linked to one or more final product leaf nodes of the Assay Tree described above. Thus, this Astree can easily access the branches of the Astrees tree that end up in the final product in the reversed order. This results tree can also be used to define element root nodes for the next level. These element root nodes can represent dataset elements for the next level, consisting of the final product set at the lower level.

An interlocking tree datastore captures information about the relationship between dataset elements that appear in the input file by combining nodes representing dataset elements and nodes representing level start indicators to form nodes representing subcomponents. can do. Subcomponent nodes can be combined with nodes representing dataset elements to generate another subcomponent node in an iterative subprocess. By combining a subcomponent node with a node representing a level end indicator, a level end product node can be created. The process of combining the level start node with the dataset element node and subcomponent with the dataset element node for subcomponent generation is iteratively executed, generating multiple asch branches in a level. As Trees may be linked to the nodes of the As Tree, such as by the root of the As Tree, which points to one or more nodes of the As Tree.

The final product node of one level may be an element root node that represents the dataset elements that are combined to generate the next level of subcomponents. This process may be repeated many times, thus generating any number of levels of the case trees. Additionally, one level of element root nodes can be resolved to generate lower level nodes and routes. The final product nodes of one level become element root nodes of the next level through a specific instance of the lower level tree, which corresponds to the lower level tree of trees with the root node representing the lower level end indicator. Thus, the lower level tree of interest with the root node representing the lower level end indicator is the second root for the inversion of the lower level of the case tree.

In one embodiment of the invention, as nodes are created, the cases and the results links are generated simultaneously at each level. Ascase branches are created by the generation of ascase links in accordance with input processing. Ascase branches of the Ascase tree at each level provide a direct record of how each subcomponent and final product of that level was created through a sequential combination of nodes representing the dataset elements. The branches of the ass tree also represent one possible vertical relationship of the nodes in the tree.

The generation of associative links creates a series of interlocking trees, each branching from a separate root. There can be multiple routes of this kind at one level. This results in recording all remaining conventions between the dataset elements appearing in the input. The above information is captured by the forest structure of the constructed interlocking trees, rather than being stored directly at the nodes of the trees. Thus, the data received as input determines the structure of the forest of constructed interlocking trees. The structure of the Astree tree forest ensures that this stored information can be accessed in any other context that requires it. Thus, the datastore is self-organizing, which will be apparent from the description below.

In addition, the operation of the present invention will be executed on a system that generates a tree-based datastore. The system can include a processor, a memory coupled to the processor, and a tree-based datastore generator for generating one or more levels of the tree-based datastore. One or more levels of the tree-based datastore comprise a first tree, a second tree, and a third tree, the first tree comprising a first root and one or more nodes of node e, and the second tree A second root and one or more nodes of the first tree, wherein the third tree comprises a third root and one or more nodes of the plurality of nodes of the first tree.

The following method is introduced to evaluate a collection of data represented by an interleaving datastore from an interlocking tree datastore that includes nodes with a count field and links between nodes. In this case, the nodes include root nodes composed of one or more primary root nodes and one or more element root nodes, and may include other nodes. The nodes also include one or more ends of a thought node, one or more subcomponent nodes, and one or more end product nodes. And there are as result and as case links, the as links point between a root node and other nodes, and the as case links point between one or more primary root nodes and one or more final product nodes Include one or more subcomponent nodes in the path between them. The method,

Determine a context and its corresponding value in the datastore,

Determine a focus and its corresponding value within the context, and

Calculating a probability of occurrence of the focus in the context using the corresponding values of the context and the focus.

Steps.

The step of determining the context and its corresponding value,

Select a context constraint list of values of the interlocking tree datastore with values represented by one or more nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression;

Identify one or more paths by the last product node from the one or more root nodes by traversing from the results list of the one or more root nodes to the corresponding subcomponent nodes of the one or more root nodes, and Intersect ascase links between subcomponent nodes to each corresponding final product node of the subcomponent node,

Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and

Add a count of the last product node of one or more paths not ignored to obtain a context count

Steps.

The logical expression includes one or more logical operators including any one of AND, OR, NOT, GREATERTHAN, LESSTHAN, XNOR, EQUALTO, and any combination of the logical operators. But not limited to this.

The step of determining the context and its corresponding value,

Select a context constraint list of values of the interlocking tree datastore with values represented by one or more root nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; ,

Identifying one or more paths by the end product node, wherein the identification process is implemented by traversing backwards from the all possible end product nodes back to the primary route using a case link along the path, where each Determine the location of the root node at the subcomponent node of the node using the result link and compare the root node to the one or more root nodes,

Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and

Add a count of the last product node of one or more paths not ignored to obtain a context count

Steps.

The method of evaluating the collection of data represented by an interlocking tree datastore is:

Determine a context and its corresponding value in the dataset,

Determine a location along each path within the context,

Determine a focus and its corresponding value in the context, and

Calculating a probability of occurrence of the focus between the position and the final product, along the path in the context.

It may also include steps.

The step of determining a location along each path of the context,

Selecting one root node from a root node or element root node of the interlocking tree datastore, and from the aslist list of the root node or element root node to its corresponding subcomponent node in each path of the context. Across

Steps.

The step of determining the context and its corresponding value,

Select a context constraint list of values of the interlocking tree datastore with values represented by one or more nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression;

Identify one or more paths by the last product node from the one or more root nodes by traversing from the results list of the one or more root nodes to the corresponding subcomponent nodes of the one or more root nodes, and Intersect ascase links between subcomponent nodes to each corresponding final product node of the subcomponent node,

Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and

Add a count of the last product node of one or more paths not ignored to obtain a context count

Steps.

The step of determining the context and its corresponding value,

Select a context constraint list of values of the interlocking tree datastore with values represented by one or more root nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; ,

Identifying one or more paths by the end product node, wherein the identification process is implemented by traversing backwards from the all possible end product nodes back to the primary route using a case link along the path, where each Determine the location of the root node at the subcomponent node of the node using the result link and compare the root node to the one or more root nodes,

Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and

Add a count of the last product node of one or more paths not ignored to obtain a context count

Steps.

Another way to evaluate the collection of data represented by an interlocking tree datastore is:

Determine a context and its corresponding value in the dataset,

Determine a location along each path within the context,

Determine a focus and its corresponding value in the context, and

Calculating a probability of occurrence of the focus between the location and the primary root, along the path in the context

Steps.

The step of determining a location along each path of the context,

Selecting one root node from a root node or element root node of the interlocking tree datastore, and from the aslist list of the root node or element root node to its corresponding subcomponent node in each path of the context. Across

Steps.

The step of determining the context and its corresponding value,

Select a context constraint list of values of the interlocking tree datastore with values represented by one or more nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression;

Identify one or more paths by the last product node from the one or more root nodes by traversing from the results list of the one or more root nodes to the corresponding subcomponent nodes of the one or more root nodes, and Intersect ascase links between subcomponent nodes to each corresponding final product node of the subcomponent node,

Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and

Add a count of the last product node of one or more paths not ignored to obtain a context count

Steps.

The step of determining the context and its corresponding value,

Select a context constraint list of values of the interlocking tree datastore with values represented by one or more root nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; ,

Identifying one or more paths by the end product node, wherein the identification process is implemented by traversing backwards from the all possible end product nodes back to the primary route using a case link along the path, where each Determine the location of the root node at the subcomponent node of the node using the result link and compare the root node to the one or more root nodes,

Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and

Add a count of the last product node of one or more paths not ignored to obtain a context count

Steps.

The step of determining the context and its corresponding value,

Select all possible paths by the final product node of the interlocking tree datastore and ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression and thus The set of derived nodes that form the context includes nodes that follow only the paths that are not ignored, and

Get a context count and add a count of the final product nodes of one or more paths not discarded

Steps.

The step of determining the focus and its value,

Select a focus constraint list of one or more root nodes from a root node or element root node of the interlocking tree datastore, wherein the one or more root nodes are associated with each other by a logical expression;

The one or more roots as a traversal from the aslist list of the one or more root nodes to any corresponding subcomponent, and the ascase link of the corresponding subcomponent node to its corresponding final product node; Identifies one or more paths from the node by the end product node,

Ignore paths that are not in the built context, and

Also ignore paths with links to element root nodes with value fields that do not match the above logical expression, so that the set of derived nodes that form the focus include nodes that follow only non-ignored paths; , And

Add a count of the last product node of one or more paths forming the focus to obtain a focus count

Steps.

In any case, the step of determining the focus and its value,

Select a focus constraint list of one or more root nodes from the root node or element root node of the interlocking tree datastore, wherein the one or more root nodes are associated by a logical expression and represented by one or more root nodes Select a context constraint list with the values that are to be generated, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression,

Identifying one or more paths by the final product node, wherein the identification process is implemented by traversing backwards along the path from all final product nodes in the established context towards the primary root node, wherein The path is identifiable using the case link of the last product node in the established context, wherein at each subcomponent node, the location link is used to determine the location of the root node and route the root node to the one or more roots. To nodes,

Derived sets of nodes that ignore paths with links to element root nodes with value fields that do not match the above logical expression, and thus form focus, include nodes that follow only paths that are not ignored, And

-Add a count of the last product node of one or more paths that are not ignored to get the focus count.

Steps.

The logical expression includes, but is not limited to, one or more logical operators including any one of AND, OR, NOT, GREATERTHAN, LESSTHAN, XNOR, EQUALTO, and any combination of the logical operators.

Our preferred structure is a node with a link between nodes, the nodes having a plurality of data fields, two or more of the plurality of fields having pointers, and one of the two or more pointers being a case pointer. And one of the two or more pointers is a result pointer, wherein the one or more nodes have one or more additional pointers to the list of pointers, and one of the additional pointers to the pointer list indicates that the node is a related ascase list. In the case of having a pointer to an assist list, another one of the additional pointers is a pointer to an assult list in a case where the node has an assult list,

The node has a count field, the node including a root node, at least one primary root node and at least one elemental root node, wherein the node may include other root nodes, The node comprises at least one end of a thought node, at least one subcomponent node, and at least one final product node, wherein the as links are pointing between a root node and other roots, and the as The case link points between one or more primary root nodes and one or more end product nodes, wherein the as case link includes one or more subcomponent nodes in the path therebetween, and the associative link includes a root or end product node. Between a subcomponent node and a final product node The element node has a field with one value.

The structure is formed from a set of program instructions that, when activated to create the structure, set up a computer system.

The structure can be generated from the program instruction set available on a computer readable medium having the program instruction set.

The count field has an intensity variable, and the intensity variable is modifiable to various intensities corresponding to various specified kinds of activities related to the node having the count field.

The ascase and aslist lists are stored in a data structure separate from the interlocking tree structure, and the separated data structure is associated with an associated node in the interlocking tree structure by a pointer.

Another type of structure we prefer is to have nodes and links between them,

The nodes have a plurality of data fields, two or more of the plurality of fields having a pointer, one of the two or more pointers being a case pointer, the other of the two or more pointers being a resort pointer, one or more The node has one or more additional pointers to the list of pointers, one of the additional pointers to the pointer list being a pointer to an ass list in the case where the node has an associated ascase list, the other of the additional pointers. One is a pointer to an Aslist list in the case where the node has an Aslist list,

Each of the nodes is provided with one subnode for traversing a specified manner, the subnode having a count field for recording traversing the node in a specified manner, the node comprising a root node, Among them there is at least one primary root node and at least one elemental root node, the node may comprise other root nodes, the node being at least one end of a thought node, at least one subcomponent. A node and one or more final product nodes, wherein the as links link between a root node and other routes, and the ascase links point between one or more primary root nodes and one or more final product nodes, and The at least one case link may be one or more subcomponent nodes. In the path therebetween, and wherein Az resolver tree links and points to the end product and between the root node and sub-nodes and end product nodes component, the element node is provided with a field that has a value of one.

Another preferred type of structure we prefer is a structure with nodes and links between nodes, the nodes having a plurality of data fields, at least two of the plurality of fields having pointers, and at least two pointers. One of the case pointers, the other of the two or more pointers is a resort pointer, the one or more nodes having one or more additional pointers to the list of pointers, and one of the additional pointers to the pointer list is the node Is a pointer to an assense list in the case of having an associated ascase list, another of the additional pointers is a pointer to an assult list in the case of the node having an assult list,

The node has an additional field, the node including a root node, at least one primary root node and at least one elemental root node, the node may comprise other root nodes, The node comprises at least one end of a thought node, at least one subcomponent node, and at least one final product node, wherein the as links are pointing between a root node and other roots, and the as The case link points between one or more primary root nodes and one or more end product nodes, wherein the as case link includes one or more subcomponent nodes in the path therebetween, and the associative link includes a root or end product node. Between the subcomponent node and the final product node The element node has a field with one value.

It is preferred that the additional field is a count field.

1 is an exemplary computing environment diagram that may implement aspects of the invention.

FIG. 2A is an illustration of an example system for generating and accessing data from an interlocking triangular datastore in accordance with one embodiment of the invention. FIG.

2B illustrates an example method of generating information and accessing information from an interlocking tree database.

FIG. 3A is a detailed view of the example interlocking tree datastore of FIG. 3A, in accordance with an embodiment of the invention. FIG.

FIG. 3B is a detailed view of an example node of the interlocking tree datastore of FIG. 3B, in accordance with an embodiment of the invention. FIG.

3C is a diagram of link lists of the interlocking tree datastore of FIG. 3A, in accordance with an aspect of the invention.

4 is a set diagram of an example of the data set elements of FIG. 2 stored in a memory in accordance with one embodiment of the invention.

5A-E illustrate the interlocking tree of FIG. 2 and corresponding content of its nodes generated in accordance with one embodiment of the invention.

6 is a flow diagram of an example process for generating interlocking trees in accordance with an embodiment of the invention.

FIG. 7A illustrates another interlocking tree datastore and corresponding nodes in accordance with an embodiment of the invention. FIG.

FIG. 7B is a link list diagram of the interlocking tree datastore of FIG. 7A, in accordance with an embodiment of the invention. FIG.

8 is a diagram of another interlocking tree datastore, in accordance with an embodiment of the invention.

9A illustrates another interlocking tree datastore, in accordance with an embodiment of the invention.

FIG. 9B illustrates content of an example of nodes of the interlocking tree datastore of FIG. 9A, in accordance with an embodiment of the invention. FIG.

10 is a diagram of another interlocking tree datastore in accordance with an embodiment of the invention.

11 is a flowchart of an example process for accessing data from an interlocking tree datastore in accordance with an embodiment of the invention.

12A and 12B are detailed views of an exemplary interlocking tree datastore with one or more additional fields.

Figure 13 is a diagram of a simple interlocking tree datastore in accordance with a preferred embodiment of the invention.

14A-D are flowcharts.

survey

The system and method introduced below creates a datastore containing one or more levels of a forest of interconnected trees. The forest of interconnected trees of each level of the datastore includes nodes or subcomponent nodes representing level start and dataset elements, and dataset element nodes or subcomponent nodes, and nodes representing level end indicators in an iterative process. Capture information regarding the combination of the. In this case, the iterative processor, as a result, generates one associative tree and a plurality of assort trees composed of nodes connected by the case tree branches. Nodes of the ascase branch branch from the first route. For example, referring to FIG. 3A, nodes 302, 312, 314, 316 are an example assortment tree branching from the first start indicator route 302. As Tree, nodes 306 and 312 (one as tree), nodes 304 and 314 (second tree), nodes 308 and 316 (de tree 3 tree), node 310 318) (fourth result tree). The fourth Astrid tree is a specific example of an Astrid tree. This is because the root (node 310) represents the final indicator.

To see this structure in its most basic form, reference may be made to FIG. 13. In FIG. 13 a minimum unit of interlocking tree datastore structure is shown, with nodes 11-15 connected by links 16-19. The basic structure will have a primary root (node 11) connected to the subcomponent node 14 via a link 16. Node 12, which is the third root (element root), will also be connected to subcomponent node 14 by link 17. Node 14 is thus an example of what is shown in the data for node 12. In other words, the data of the node 14 is an example of the data of the element node 12. Node 15 is connected to node 14 by link 19, and paths 11-16-14-19, 15 may be called paths or threads starting at the primary root and ending at the final product node. have. The path can be a link and a connecting line of nodes. The final product node is an example of the second root node 13 and is connected by a link 18.

Each branch of the level tree of the level begins with a combination of nodes representing level start indicators and nodes representing dataset elements for subcomponent nodes. The subcomponent node may be iteratively combined with the dataset elements for another subcomponent node. The subcomponent can be combined with the node representing the level end indicator to generate the final product node. This processor may be iterated, eventually forming a plurality of case tree branches branching from the first root.

For example, if indivisible elemental components of a particular interlocking tree structure are alphanumerics, the subcomponents may be a combination of spells rather than words, and the final product may be a word. Alternatively, the subcomponents can be a combination of alphanumeric characters, including partial stock numbers or order numbers, and the final product can be a completed stock or order number. This merely refers to two of the various alphanumeric input applied to the present invention.

The final products of one level may be dataset elements of the next level. The final product dataset elements can be used to generate the next level of subcomponents in the same way that the lower level dataset elements are used to generate the lower level subcomponents and the final product. For example, in the particular interlocking tree structure described above, one level of final product may be a dataset element capable of generating a higher level final product. This process can be repeated many times, creating numerous levels of the case tree on the datastore.

To continue the above example, the higher level may include a sentence by using words as the level dataset elements. Sentences can be combined to create paragraphs (also unit high levels). Additionally, the higher level dataset elements can be decomposed to generate lower level interlocking tree datastores. In one embodiment of the invention, an Astrib tree starting from the level end indicator is used to define the next level of dataset elements. This end indicator corresponds to the second route in an inverted order of interlocking tree datastores defined by the ascase tree in one embodiment of the invention.

As nodes are created, at each level, as-case and as-result links may occur simultaneously. The ascase link represents the link to the first of the two nodes, from which nodes are created. Ascase branches of ascase trees may be created by generation of ascase links in accordance with input processing. Ascase branches of each level provide a direct record of how each subcomponent and final product of that level was created. Thus, case branches can be used for applications where it is useful to know how subcomponents and end products are created. For example, if the input to the interlocking tree generator includes correctly spelled words, the ascase links of the interlocking trees generated as such can be used as a spelling checker, which is just one example of a number of applications in the datastore. .

In addition, the branches of the ass tree represent one vertical relationship of the nodes of the ass tree. For example, if the data received by the interlocking tree generator is "Tom sold 100 PA. Bill sold 40 NJ", the generated case tree is a view of the data in the "state information within the context of salesman" context or vertical structure. It includes.

The Aslink link represents the link to the second of the two nodes, from which nodes are created. The generation of the associative links creates a series of interlocking trees, each branching from the root containing the dataset element. This results in recording all encounter relationships between elements in the datastore and the case trees. In other words, the As Trees capture the nodule's possible context of interlocking trees. As Trees can be used in fields where it is useful to know the relationship or context between nodes. If the input to the interlocking tree datastore generator includes extensive sales data including seller name, day of the week, item number, and state, the associative links in the generated interlocking tree datastore are " What do you sell in a particular state? "," How many items did you sell on Monday? "," How many items did Seller Bob sell on Monday and Tuesday? " Can be used to extract information such as This is all obtained from the same interlocking tree datastore and does not create multiple copies of the datastore.

Subcomponents and final products may be classified using information stored in the As Tree. The information is stored by the structure of the built interlocking tree database rather than directly in the subcomponents and final products of the tree. Because only the root node of an interlocking tree datastore can contain data, the associative links return back to the root node to determine whether its subcomponents or end products belong to the class of data represented by the root node. You can go back. This feature makes the datastore self-organizing. This will be explained in detail below. For example, if the input to the interlocking tree datastore generator is "CAT TAB", the information stored in the structure of the resulting interlocking tree datastore is the final product "BOT-CAT-EOT" and "BOT-TAB-EOT". Can be used to determine whether the element contains the element "A", or whether the class of the subcomponent / final product with "A" contains "BOT-CAT-EOT" and "BOT-TAB-EOT". Can be used to determine. Furthermore, by following the ascase links of the nodes with "A", other subcomponents and end products with "A" can be found along the branches of the ascase tree.

In one embodiment of the invention, the links between nodes are bidirectional. For example, a root node representing the letter "A" may contain a pointer to node BOT-CA in node A's results list, and node BOT-CA is an pointer to node A as an alias pointer. It may include.

In another embodiment of the invention, the links between nodes are unidirectional. For example, in this embodiment, node BOT-C-A includes an asspointe pointer to node BOT-C and includes an pointer to the root node representing A. However, root node A does not include a pointer to node BOT-C-A in the results list. Information about which node is a node of class A may still be determined, but this may require a search of all nodes.

Example Compute Environment

1 is a block diagram of a computer system 100 that may implement aspects of the present invention. Computer system 100 may be any suitable system, such as a mainframe, minicomputer, IBM compatible PC, Unix workstation, network computer, or the like. The apparatus of the present invention can be applied to any computer system including a single user computer or a multi-user computer system. As shown in FIG. 1, computer system 100 includes a central processing unit (CPU) 102 connected to main memory 104, auxiliary storage interface 106, terminal interface 108, and network interface 110. It includes. These system components are connected via system bus 160. Auxiliary storage interface 106 is used to connect storage devices such as DASD device 190 to computer system 100 that store data on disks such as disk 195.

Main memory 104 encompasses the entire virtual memory of computer system 100 and includes an operating system 122 and an application 124, and may also include an interlocking tree datastore 126. Interlocking tree datastore 126 can be used to provide a data storage device that can quickly retrieve data in a multiple context mode without requiring data duplication. Computer system 100 is a known virtual that allows programs in computer system 100 to behave like accessing a large single storage entity rather than accessing multiple small storage entities such as main memory 104 and DASD device 190. The addressing mechanism can be used. Thus, although operating system 122, application 124, and interlocking tree datastore 126 are shown as being located in main memory 104, these elements may all be fully located in main memory 104 at the same time. There is no need.

Although computer system 100 is shown to include only a single CPU and a system bus, the present invention may be implemented using a system that includes multiple CPUs and multiple buses. Terminal interface 108 may be used to connect one or more terminals to computer system 100. Exemplary terminals include dumb terminals or fully programmable workstations, which allow system administrators and users to communicate with computer system 100.

Network interface 110 may be used to connect other computer systems or workstations to computer system 100. The network interfaced with the network interface 110 may be a suitable network, such as a LAN, WAN, Internet, extranet, or the like. The operating system can be any suitable operating system, such as OS / 2, Windows, AIX, Unix, LINUX, and the like.

Application 124 may be any kind of application that accesses data stored in interlocking tree datastore 126. Thus, applications may include data analysis applications, data storage applications, command detection systems, and the like.

Interlocking tree datastore 126 provides a data storage structure that allows a user to access the same datastore to obtain information related to any context. The term data herein may include any kind of information stored by a computer, such as numbers, text, graphics, formulas, tablets, audio, video, multimedia, or any combination thereof. Interlocking tree datastore 126 may be implemented as part of application 124, as part of operating system 122, or as a separate datastore product designed to provide data storage for various applications.

Although described with respect to a fully functional computer system of the present invention, the present invention may be distributed in various forms of program products. The invention also applies equally to the signal carrier medium carrying this distribution. Examples of media that carry these signals include floppy disks, hard drives, CDROMs, digital and analog communication links, and the like.

Interlocking  tree Datastore  Systems and Methods for Generation and Access

2A illustrates an example system 200 for generating data from and accessing data from a forest of interlocking trees comprising a datastore, in accordance with an embodiment of the invention. In one embodiment, the interlocking tree datastore The subsystem 250 for generating the interpolation includes an interlocking tree generator 202, a dataset element set 206, and input data 204. An example interlocking tree datastore 208 is generated from the input data 204.

Subsystem 251 to access information from interlocking tree datastore 208 may include interlocking tree datastore 208 and interlocking tree datastore accessor 210. The accessor 210 receives the data request 212, processes the data request 212, and returns the requested information.

2B illustrates an example method for generating information from and accessing the interlocking tree datastore. At step 260, an interlocking tree datastore is generated. In step 262, a request for information is received from an interlocking tree datastore. In step 264, information is retrieved from the interlocking tree datastore.

Interlocking  tree Datastore  Occur

For example, suppose the input data 204 includes a stream of alphanumeric characters representing a word (eg, "CAT"). In this case, the dataset elements 206 may be a set of alphabetic spellings and may include one or more characters representing a word start and word end concept or delimiter. Each root and non-root node of interlocking tree datastore 208 has a pair of pointers (case pointers and resort pointers), a pair of list pointers (pointers to ascaselists, and aslists). Pointer). Routes can additionally contain data representing a value or a reference to a value.

3A is a detailed view of an example interlocking tree datastore 208. Some nodes, such as root nodes 302 (BOT) 310 (EOT), represent concepts such as start indicators or end indicators, such as root node 304 (A) 306 (C) 308 ( T) represent dataset elements. Other nodes, such as node 312 (BOT-C) 314 (BOT-CA) 316 (BOT-CAT) 318 (BOT-CAT-BOT), may represent a start indicator; A node representing a dataset element is synthesized sequentially by a node representing a subcomponent combined with a dataset element for another subcomponent. The sequential synthesis then continues until the subcomponents are combined with the nodes representing the final indicators to produce the nodes representing the final products. In this case, we capture a sequential synthesis of words from a series of spellings and delimiters. The delimiter at the input can function to distinguish the final product. For example, the letters defining the words may function to mark the end of one word and the start of another word. For example, in the string "CATS ARE", the blank character between "CATS" and "ARE" marks the end of the word "CATS" and the beginning of the word "ARE" simultaneously. Thus, a delimiter, such as a blank character at the input, can be changed to a start indicator such as "BOT" or to an end indicator such as "EOT" at the node being created.

Nodes such as root nodes 304, 306, 308 are called element nodes. This is because these nodes represent dataset elements and contain indivisible units. From these non-dividable units, a splittable unit (subcomponent and final product) is constructed. Nodes 312, 314, and 316 are called subcomponents or subcomponent nodes. Because these nodes are combinations of conceptual indicators, such as start indicators, nodes representing dataset elements, or combinations of subcomponents and nodes representing dataset elements that do not contain the final product, or subcomponents, This is because it represents a combination of nodes representing the final indicator that does not contain the final product. Nodes such as node 318 represent the final product. In this example, data elements are spelled, subcomponents represent a combination of spells that do not contain a word, and the final product is words. The root set contains "BOT". This is, in this example, marking the beginning of a word. The root set also contains "EOT". This is an indication of the end of the word in this example. Although "BOT" and "EOT" represent start and end indicators, the invention is not so limited. Other indicators may also be considered. In one embodiment, because of the link from one node to the root node representing the EOT concept, the final product is distinguishable from the subcomponent.

In the given example, the input is a number set, from which the words can be derived. However, the present invention is not limited thereto. For example, the input may be text such as a procedure or words, or it may be a limited resource used for processes, concepts, pixel sets, images, sounds, numerical values, analog measurements, and the like. For example, the input can be an amino acid, from which the genome can be derived. In general, according to one embodiment of the invention, the element units are combined into an optimized sequence.

In addition to the nodes described above, interlocking tree datastore 208 may include multiple links between nodes, such as links 320, 322, 324, 326 and links 328, 330, 332, 334. have. In one embodiment of the invention, links 320, 322, 324, 326 and links 328, 330, 332, 334 are bidirectional. That is, a path between the root node BOT and the node 318 (BOT-C-A-T-EOT) may lead in both directions via links 320, 322, 324, and 326. The links 320, 322, 324, 326 are called ascase links. Links 328, 330, 332, 334 are called as results links. Similarly, in one embodiment of the invention, the links 328, 330, 332, 334 are bidirectional such that a pointer at node C 306 points to node BOT-C 312 and a pointer to node BOT-C 312. Points to node C 306, a pointer of node A 304 points to node BOT-CA 314, and a pointer of node BOT-CA 314 points to node A 304.

3B shows information contained in an example node of interlocking tree datastore 208. An example node 340 may represent a subcomponent or final product. An example node 340 may be a pointer to a first component of a subcomponent or final product 340 (ie, a pointer to a case 342 called an ascase), a second portion of a subcomponent or final product 340. It may include a pointer to (i.e., a pointer to a resort 344 called as an outcome), a pointer to an as-case list 346, and a pointer to an as-list list 348. In this case, the assist list 346 is a linked list of subcomponents or final products of which the node 340 corresponds to the first part, and the aslist list 348 is a node of the node 340 corresponding to the second part. A linked list of subcomponents or final products.

An example node 341 represents an element node. 12A and 12B will be mentioned in the next paragraph for the description of a node with additional fields needed for some of the functions described later. The example node 341 includes one null pointer (pointer to case 342 called as case), second null pointer (pointer to resort 344 called as resort), ascase list 346 It contains a pointer to, a pointer to the alias list 348, and a value 349. At this time, the case list 346 is a linked list of subcomponents or final products in which the root node 341 corresponds to the first part, and the aslist list 348 is a root node 341 in the second part. A linked list of corresponding components or end products. The value 349 may have an actual value, may represent a condition or state, and may have a pointer or reference to the value or the like. Thus, in one embodiment of the invention, the root node representing the start indicator concept or condition will have a null results list. This is because the empty indicator cannot be the second part of the subcomponent. The root node representing the dataset element will have a null assist list. This is because a dataset element cannot be the first part of a subcomponent. The root node representing the end indicator concept or condition will have a null assist list. This is because the end indicator cannot be the first part of the subcomponent. Finally, the root node, consisting of the low-level final product, will have a null as-case list. Because the final product acts as a dataset element for the next level.

All nodes of an interlocking tree datastore may also include additional fields representing data related to the node. This can be explained using a diagram similar to that of FIG. 3B (FIGS. 12A and 12B). 12A and 12B, subcomponent and element node fields are shown as fields of the description field block.

An example node 20 is shown in FIG. 12A. This node 20 may include a string field as an additional field. The string field has a sequence showing all the elements represented by this node. By adding a string field containing this sequence of elements, you help with debugging. There are many uses for this additional field, and nodes such as node 20 need not be constrained to one additional field.

The example node 30 shown in FIG. 12B also includes a count field 31. The count field is initialized and incremented with the intensity variable. The value changes depending on the condition when the count field is referenced. Intensity variables are defined as mathematical entities that hold one or more invariants. As this item is widely noisy, the count field represented by the compensating variable can be used in the application of the interlocking tree structure of the present application, recording data loss, misrecorded data, entry processing inquiries, inquiries in use. It allows you to deal with the types of records, and other processes of interest. One simple example of the intensity variable is a single order field value such as "1", which can be used to increment the count field to record the number of times the node has been accessed.

Moreover, intensity parameters can vary in different speeds and in different directions for these various functions. A simple example of different strengths is to add a value of +1 each time a query passes through a node, and add a value of -100 if the path with that particular node is considered to be an error. This is the case, for example, when a missed spell has been used to find a sequence, a sensor detects an area with dangerous chemicals, or a child simulator touches or burns a hot stove in a simulation. An alternative to the intensity variable is to use a separate node to hold a new value for each kind passing through the node. So, create a cluster in a situation where a node is accessed during a query of type 1, type 2, experience 1, experience 2, and so on.

In the present consideration of the real world application of this structure, the intensity variables of the count field provide the simplest and best approach to this problem to date. However, other alternatives should be considered and reconsidered as information processing system attributes. If this alternative is considered, one approach to implementing this approach would be to use a separate node, or even an element node or root node to record a count of the number of times it passes through each type of node. will be.

Thus, the count field can be incremented when new data is incorporated into the interlocking tree datastore. However, incrementing or decrementing the count field may be omitted when the interlocking tree datastore is queried to derive a larger value for new data and no change to the query. Therefore, this strength parameter should be selected according to the suitability for the problem handled by the present invention.

A count field is added to facilitate the use of the knowledge store represented by the interlocking tree structure, which is particularly useful when statistics such as frequency and probability are needed.

Referring to FIG. 12A, an alternative example node 20 is shown. This node 20 may be an element node 20A with a value field 22, or may be a subcomponent node or a final product node 20B (missing the value field 32). In either case, however, this node will have an additional field 21.

Specific examples of additional fields are shown in FIG. 12B. In FIG. 12B the node type 30 (element node 30A with value field 32, or subcomponent or final product node 30B) has an additional field 31 (excitation count field).

3C shows an associative link list of interlocking tree datastore 208. Link 350 is established by setting a pointer to the Aslist list of node C 306 to node BOT-C 302, and link 352 to node A 304 to node BOT-CA 314. Link 354 is constructed by setting the pointer of the Aslist list of the node T 308 to the node BOT-CAT 318, and the link 356 Is constructed by setting a pointer to the aslist list of node EOT 310 to node BOT-CAT-EOT 318.

4 shows an example of storing the BOT, a-Z, and EOT corresponding to the example dataset element 206 in the memory 104. As shown, the BOT is stored at position zero. A is stored at position 5, and so on, EOT is stored at position 135. The arrangement of dataset elements is merely illustrative and other suitable arrangements may be considered. 5A-E illustrate the contents of nodes of an interlocking tree datastore 208 and an interlocking tree datastore as interlocking tree datastore 208 occurs in accordance with one embodiment of the invention. 6 is a flow diagram of an example process 600 for generating an interlocking tree datastore 208 in accordance with one embodiment of the invention.

4, 5 and 6, in step 602, an interlocking tree datastore is initialized. In one embodiment of the invention, the initialization comprises setting a "current pointer" to the root node of the interlocking tree datastore to be created. In another embodiment, the initialization includes setting a "current pointer" at the root of an existing interlocking tree datastore.

Additionally, dataset elements can be loaded into memory and initialized. In one embodiment, the root node (eg, root node BOT 302, A 535a,..., EOT 559a in FIG. 5A) is initialized with the following values. Case Pointer = Null, Result Pointer = Null, Pointer to Ascase List = Null, As Case List = Null, Pointer to Aslistist = Null, Asreactlist = Null, and the dataset element or concept A value for a condition indicator, or representations thereof.

In this case, an interlocking tree datastore, such as an interlocking tree datastore 500a, may include a single node BOT 302 that marks the beginning of a word. Node 302 in block diagram 502a includes a pair of pointers (null initialized case pointer 504a and a result pointer 506a), and a pair of list pointers (pointer to null initialized assist list and results list. Pointer) and one value (value 511a is initialized to BOT in this embodiment). For ease of understanding, in FIG. 5, the block cells 502a, cells 508a, and similar cells shown in 502c-502e are the interlocking tree datastores as actual representations of pointers to the associated ascaselists. The current contents of the case list are shown instead. Similarly, the similar cells represented in cells 510a and 502c-502e represent an interlocking tree datastore as a pointer to the associated Aslist, instead representing the current content of the associated Aslist.

As case list (eg, as case list 508a) and as result list (eg, asistlist 510a) may be implemented as a linked list. In another embodiment, the cases list (eg, ascase list 508a) and the results list (eg, assultlist 510a) are assigned to a block of contiguous memory locations of configurable size, such as an array. For example, the pointer to the assist list is set to the start position of the assist list memory block, and the pointer to the assult list is set to the start position of the aslist list memory block.

In step 604, an input is received. In one embodiment, the value of "current pointer" is set to "previous pointer" and "current pointer" is set as input. In the given example, the received input is "C". In step 604, the input is validated. In the example given, this verifies that "C" is a valid dataset element. "C" is, of course, a valid element, which is disposed at position 15 of memory 104.

In step 606, if the node does not exist, the node is created in the interlocking tree datastore, initialized, and stored in a location in memory. In this example, node 312 of interlocking tree datastore 208 is created representing BOT-C. The case pointer of the node BOT-C 312, the result pointer, the pointer to the as case list, the as case list, the pointer to the as resolve list, and the as result list are initialized to null, and the BOT-C stores the memory ( 104 is stored as location 140.

In step 608, according to one embodiment of the invention, links to the node created in step 606 are created. The new node is defined by setting the case pointer of the new node to the value of the old pointer, and setting the result pointer of the new node to the value of the current pointer. The interlocking tree datastore 500b of FIG. 5B shows the interlocking tree datastore 208 after link creation. After link creation, the contents of node BOT 302, C 306, and BOT-C 312 are shown in block diagram 502c. The subcomponent BOT-C 312 is created by sequentially combining the node BOT 302 with the node C 306. Therefore, the following values are set for the case pointer and the result pointer. The case pointer 520b of the node BOT-C 312 is set to 0 (the position of the node BOT 302 of the memory 104), and the position of the result pointer 522b of the node BOT-C 312 is 15. Is set (position of element node C 306 in memory 104).

In one embodiment of the invention, in addition to creating a link from the new node to the node that derived the new node, in the linked lists of nodes that derived the new node, namely the assist list and the results list, By adding a pointer to the location of the node, the caselist and aslistlist links are created. Pointers may be added to the end of the list, may be added to the beginning of the list, or may be inserted somewhere in the list. In addition, multiple lists may be maintained. For example, the node's case list may include a sequential list that adds pointers to the endpoints of the linked list, in addition to an ordered list that holds pointers in the order in which they are most frequently accessed. Although the example given refers only to one order list and one sequence list, the invention is not so limited. The order list may be ordered by last update, last access, frequency of updates or accesses, or other appropriate rules.

Links to the new node are made. The pointer to the new node is added to the case list of the previous pointer and added to the aslist of the current pointer. In this example, the case pointer 520b of node BOT-C 312 is set to the position of node BOT 302, that is, position 0 (link 320a in block diagram 503b), and node BOT- By adding a pointer to the location of C 312, i.e., location 140, to the case list 508b, the bidirectional link 320 is updated by updating the case list 508b (link 320b) of the node BOT 302. Is generated. Since node BOT 302 is one of the nodes forming node BOT-C 312, case pointer 520a is set. As node list 508b is updated because node BOT 302 is used in the synthesis of node BOT-C 312 corresponding to the first of the two nodes creating node BOT-C 312. Ascaselist 508b currently has a null set (ie, ascaselist 508b is empty). As node BOT-C 312 is located at location 140 in memory 104, as-case list 508b is updated from null to 140. If the caselist 508b is configured with a non-null set, the node BOT-C 312 location 140 will be added to the ascaselist 508b in one of the ways described above.

Similarly, by setting the result pointer 522b of node BOT-C 312 to the position of node C, that is, position 15 (link 328a of block diagram 503b), and node BOT-C 312. The bidirectional link 328 is generated by updating the results list 518b (link 328b) of element node C 306 by adding a pointer to the location of s to the results list 518b. The result pointer 522b is set because node C 306 is one of the nodes forming node BOT-C 312. Aslist list 518b is updated because node C 306 includes the second of the two nodes that create node BOT-C 312. Thus, the link 328b is called an associative link. Asrelicist 518b currently has a null set. In other words, the results list 518b is empty. As node BOT-C 312 is located at location 140 of memory 104, aslist list 518b is updated from null to 140. If the results list 518b consists of a non-null set, then the node BOT-C 312 location 140 will be added to the results list 518b in one of the ways described above.

At this time, an interlocking tree datastore 500b corresponding to the datastore shown in FIG. 5B is generated. The same structure is represented in detail in block diagram 503b in FIG. 5B. Link 320b represents a pointer to the location of node BOT-C 312, which is the first element of the assistlist 508b for node BOT 302, where link 328b is node BOT-C. Represents a pointer to the location of 312, and corresponds to the first element of the results list 518b of node C (306). Link 320a represents a pointer to node BOT 302 that is its first part from node BOT-C 312, and link 328a represents node C 306 that is its second part from node BOT-C 312. Represents a pointer to).

In step 610, it is determined whether there is more input. In this case, there is more input and the process returns to step 604. In step 604, the input is validated. In this example, this involves checking that "A" is a valid dataset element. "A" is, of course, a valid element and is located at position 5 in memory 104.

In step 606, if the node does not exist, node 314 of interlocking tree datastore 208 is created to represent the BOT-C-A. The case pointer of the node BOT-CA 314, the result pointer, the pointer to the as-case list, the pointer to the as-case list, the as-list, and the as-list are initialized to null, and the node BOT-CA 314 is initialized to null. ) Is stored in memory 104 at location 145.

In step 608, according to one embodiment of the invention, links to the node created in step 606 are created. 5C shows an interlocking tree datastore 500c as the creation of links. The contents of node BOT 302, C 306, A 304, BOT-C 312, and BOT-C-A 314 are shown in block diagram 502c. Subcomponent BOT-C-A 314 is created by sequentially combining node BOT-C 312 with node A 304. Therefore, the following values are set for the case pointer and the result pointer. Case pointer 528c of node BOT-CA 314 is set to 140 (link 322a) (location of element node BOT-C 312 in memory 104), and result pointer of node BOT-CA 314 The position of 530c is set to 5 (link 330a) (the position of element node A 304 in memory 104).

By setting the case pointer 528c to 140 (link 322a), and by adding a pointer to the location of node BOT-CA 314 to the case list 524c of node BOT-C 312, Link 322 is generated. As case list 524c is updated because node BOT-C 312 includes the first of the two nodes that create node BOT-C-A 314. Prior to creating the link 322b, the case list 524c of the node BOT-C 312 has a null set. In other words, the case list 524c is empty. As node BOT-C-A 314 is found at position 145, ascase list 524c is updated from null to 145. If the cases list 524c is configured with a non-null set, node BOT-C-A 314 location 145 will be added to the cases list 524c in one of the ways described above.

Similarly, by setting the result pointer 530c of the node BOT-CA 314 to position 5, and a pointer to the position of the node BOT-CA 314 to the results list 542c of the node A 304. By updating the results list 542c of element node A 304 in addition to, the bidirectional link 330 is generated. Aslist list 542c is updated because node A 304 includes the second of two nodes that form node BOT-C-A 314. Prior to creating the link 322b, the Aslist List 542c has a null set. In other words, the results list 542c is empty. As node BOT-C-A 314 is located at location 145 of memory 104, aslist list 542c is updated from null to 145. If the results list 542c is configured as a non-null set, then node BOT-C-A 314 location 145 will be added to the results list 542c in one of the ways described above.

At this time, an interlocking tree datastore 500c corresponding to the datastore shown in FIG. 5C is generated. The same structure is represented in detail in block diagram 503c in FIG. 5C. Link 322b represents a pointer to the location of node BOT-CA 314, which is the first element of the assistlist 524c for node BOT-C 312, where link 330b is a node BOT. Represents a pointer to the location of the CA 314, which corresponds to the first element of the Aslist list 542c of node A 304. Link 322a represents a pointer to node BOT-C 312 that is its first part from node BOT-CA 314, and link 330a represents node A that is its second part from node BOT-CA 314. Represents a pointer to 304.

In step 610, it is determined whether there is more input. In this case, there is more input and the process returns to step 604. In step 604, an input is received. In the example given, the input received is "T". In step 604, the input is validated. In this example, this involves checking that "T" is a valid dataset element. "T" is, of course, a valid element and is located at position 100 in memory 104.

In step 606, if the node does not exist, the node of the interlocking tree datastore is created, initialized, and stored in a location in memory. In this example, node 316 of interlocking tree datastore 208 is created to represent BOT-C-A-T 316. The case pointer, the result pointer, the pointer to the ascase list, the pointer to the ascase list, the aslist, and the aslist are initialized to null, and the node BOT-CAT 316 is stored in memory 104. It is stored at location 150

In step 608, according to one embodiment of the invention, links to the node created in step 606 are created. 5D shows an interlocking tree datastore 500d as the creation of links. The contents of node BOT 302, C 306, A 304, T 308, BOT-C 312, BOT-CA 314, and BOT-CAT 316 are block diagrams 502d. Is shown. The subcomponent BOT-C-A-T 316 is created by sequentially combining the node BOT-C-A 314 with the node T 308. Therefore, the following values are set for the case pointer and the result pointer. The case pointer 544d of the node BOT-CAT 316 is set to 145 (the position of the node BOT-CA 314 of the memory 104), and the position of the result pointer 546d is set to 100 (the memory ( 104) location of element node T 308).

By setting the case pointer 544d to 145 and adding a pointer to the location of the node BOT-CAT 316 to the case list 532d of the node BOT-CA 314, the bidirectional link 324 occurs. do. As node list 532d is updated because node BOT-C-A 314 includes the first of two nodes that create node BOT-C-A-T 316. Prior to creating the link 324, the ascase list 532d of the node BOT-C-A 314 had a null set. In other words, the case list 532d was empty. As node BOT-C-A-T 316 is found at position 150, ascase list 532d is updated from null to 150. If the case list 532d has data, node BOT-C-A-T 316 location 150 will be added to the case list 532d in one of the ways described above.

Similarly, by setting the result pointer 546d to position 100, and adding a pointer to the position of node BOT-CAT 316 to the results list 558d, the results list of element node T 308. By updating 558d, a bidirectional link 332 is generated. Aslist list 558d is updated because node T 308 includes the second of two nodes that create node BOT-C-A-T 316. Prior to creating the link 332, the Aslist List 558d of the element node T 308 had a null set. That is, the null set is changed to 150. This location is the location in memory 104 of node BOT-C-A-T 316. If the results list 558d has data, node BOT-C-A-T 316 location 150 will be added to the results list 558d in one of the ways described above.

At this time, an interlocking tree datastore 500e corresponding to the datastore shown in FIG. 5D is generated. The same structure is represented in detail in block diagram 503d in FIG. 5D.

In step 610, it is determined whether there is more input. In this case, there is more input and the process returns to step 604. In step 604, an input is received. In the given example, the input received is "", or blank character. In step 604, the input is validated. In this example, this involves checking whether the blank character is a valid dataset element. The blank character is, of course, a valid element and is a delimiter indicating the end point of the word "CAT". Thus, in one embodiment of the invention, node EOT 310 located at location 135 is added to subcomponent BOT-C-A-T 316 to produce the final product corresponding to one word in this case.

In step 606, if the node does not exist, the node of the interlocking tree datastore is created, initialized, and stored in a location in memory. In this example, node 318 of interlocking tree datastore 208 is created to represent BOT-C-A-T-EOT 318. The case pointer, the result pointer, the pointer to the ascase list, the aslist, the pointer to the aslist, and the aslist of the BOT-CAT-EOT 318 are initialized to null, and the node BOT-CAT- is initialized to null. EOT 318 is stored in memory 104 at location 155.

In step 608, according to one embodiment of the invention, links to the node created in step 606 are created. 5E illustrates an interlocking tree datastore 500e as the creation of links. Nodes BOT 302, C 306, A 304, T 308, EOT 310, BOT-C 312, BOT-CA 314, BOT-CAT 316, and BOT- The contents of CAT-EOT 318 are shown in block diagram 502e. The final product BOT-C-A-T-EOT 318 is created by sequentially combining the node BOT-C-A-T 316 with the node EOT 310. Accordingly, the following values are set for the case pointer and the resort pointer of the node BOT-C-A-T-EOT 318. The case pointer 568e of the node BOT-CAT-EOT 318 is set to 150 (the position of the node BOT-CAT 316 in the memory 104), and the position of the result pointer 570e is set to 135 ( Location of element node EOT 310 in memory 104).

By setting the case pointer 568e to 150 and adding a pointer to the location of the node BOT-CAT-EOT 318 to the case list 548e of the node BOT-CAT 316, the bidirectional link 326. Is generated. As node list 548e is updated because node BOT-C-A-T 316 includes the first of the two nodes that create node BOT-C-A-T-EOT 318. Prior to creating the link 326, the ascase list 548e of node BOT-C-A-T 316 had a null set. In other words, as-case list 548e was empty. As node BOT-C-A-T 316 is found at position 155, ascase list 548e is updated from null to 155. If the caselist 548e is configured with a non-null set, then node BOT-C-A-T location 155 will be added to the caselist 548e in one of the ways described above.

Similarly, by setting the resort pointer 570e of the node BOT-CAT-EOT 318 to position 135, and a pointer to the position 155 of the node BOT-CAT-EOT 318 as an alias of node EOT 310. By updating the results list 566e of node EOT 310 in addition to try 566e, bi-directional link 334 is generated. Aslist list 566e is updated because node EOT 310 includes the second of two nodes that create node BOT-C-A-T-EOT 318. Prior to creating the link 334, the asylistist 566e had a null set. In other words, the Aslist List 566e was empty. Because node BOT-C-A-T-EOT 318 is located at position 155, aslist list 566e is updated from null to 155. If the results list 566e has data, node BOT-C-A-T-EOT 318 location 155 will be added to the results list 566e in one of the ways described above.

At this time, an interlocking tree datastore 500e corresponding to the datastore shown in FIG. 5E is generated. The same structure is represented in detail in block diagram 503e in FIG. 5E.

In step 610, it is determined whether there is more input. In this case, the input djqtdj process ends at step 612.

Now consider an input 204 with "CAT TAB" instead of "CAT". The following process is followed. Processing the input of " CAT " generates the interlocking tree datastore 500e of Fig. 5E. In step 610 there is an additional input. However, the process continues, reaching the interlocking tree datastore 700a of FIG. 7A. Node BOT 302, C 306, A 304, T 308, B 718, EOT 310, BOT-C 312, BOT-CA 314, BOT-CAT ( 316), BOT-CAT-EOT 318, BOT-T 703, BOT-TA 705, BOT-TAB 707, and BOT-TAB-EOT 709 include block diagram 702a. Is shown. Nodes BOT-T 703, BOT-TA 705, BOT-TAB 707, and BOT-TAB-EOT 709 are added to the interlocking tree datastore 500e, and the interlocking tree datastore 500e is added. 700a).

In this process, ascase links 701, 704, 706, and 708 have been created, and as result links 710, 712, 714, 716 have been created. As-case pointer 720f of node BOT-T 703 is set to 0, which corresponds to the position of node BOT 302. As pointer 722f of node BOT-T 703 is set to 100, which corresponds to the location of node T 308. The as-case pointer 728f of the node BOT-T-A 705 is set to 170 and corresponds to the position of the node BOT-T 703. The as pointer 730f of the node BOT-T-A 705 is set to 5 and corresponds to the position of the node A 304.

The add as link 701 is created by adding 170, the location of the BOT-T 703, to the as list 508f of the node BOT 302. Thus, the case list 508f includes both 140, which is the position of the BOT-C 312, and 170, which is the position of the BOT-T 703. By adding 175, which is the location of the BOT-T-A, to the case list 724f of the node BOT-T 703, an ascase link 704 is generated. As-case link 706 is created by adding 180, which is the position of BOT-T-A-B, to the case list 732f of node BOT-T-A 705.

The add link 710 is created by adding 170, which is the location of the BOT-T 703, to the resolve list 558f of the node T 308. FIG. Thus, the aslist list 558f includes both the position 150 of the node BOT-C-A-T and the position 170 of the BOT-T 703. The add link 712 is created by adding 175, which is the location of the BOT-T-A, to the aslist list 542f of the node A 304. Thus, the results list 542f includes both the position 145 of the node BOT-C-A 314 and the position 175 of the node BOT-T-A. The add link 714 is created by adding 180, which is the position of the node BOT-T-A-B 707, to the aslist list 742f of the node B 718. Since the asylistist 742f of node B 718 was previously null, the asylistist 742f of node B 718 has only 180, which is the position of node BOT-T-A-B 707. As links 716 are created by adding 185, which is the location of the BOT-T-A-B-EOT 709, to the Aslist list 566f of the node EOT 310. As shown in FIG. Thus, the aslist list 566f includes both the position 155 of the node BOT-C-A-T-EOT 318 and the position 185 of the node BOT-T-A-B-EOT 185.

Consider the case of entering 204 CATS CATHODE instead of CAT. The above process is followed. Processing the input " CAT " generates the interlocking tree datastore of FIG. 5D. At step 610, additional input is found and the process continues. Following processing of the input " CATS ", the interlocking tree datastore 800a of FIG. Additional input was found. As "CATHODE" was processed, no new nodes were created for BOT-C, BOT-C-A, BOT-C-A-T. Because they exist. Additional input "S CATHODE " is processed to derive interlocking tree datastore 800b of FIG. The resulting tree is self-organizing, so the structure of the resulting interlocking tree datastore depends on the incoming input.

Consider the case of entering (204) "CATS ARE FURRY" instead of "CAT". 9A illustrates an interlocking tree database 900 generated in accordance with one embodiment of the invention. In this example, the presence of an indicator of an entry, such as a phrase-end or character-end indicator, indicates that one level of final products (eg, BOT-CAT-EOT 908, BOT-ARE-EOT 906, BOT-FURRY-EOT 904). ) Can be triggered to combine the next level of subcomponents. That is, the final product nodes of one level (e.g., level 1 910) (e.g. words such as "CATS", "ARE", "FURRY") are the data of the next level (e.g., level 2 912). It can be a root node that represents set elements. Thus, node "BOT-CATS-ARE-FURRY-EOT" 902 is a single node representing the "CATS ARE FURRY" sentence.

In one embodiment of the invention, nodes representing higher level dataset elements have no data, or representations of data or concepts. That is, element root nodes that represent upper level dataset elements only have pointers to lower level nodes. For example, FIG. 9B shows the content of some of the nodes of FIG. 9A. Node BOT-C-A-T-S-EOT at level 1 910 is being used as the element root node at level 2 912. Aslist list 914 of node 908 has a position of node BOS-CATS 916, 300, and aspoint pointer 918 of BOS-CATS 916 to BOT-CATS-EOT 908. Has a position of 200.

Any suitable number of levels can be generated. For example, in the field of text, levels can represent spelling, words, sentences, phrases, chapters, books, libraries, and the like. In the drawings herein, only two levels of interlocking tree datastores (level 1 910, level 2 912) are shown, but the invention is not so limited. An interlocking tree datastore can be constructed with any number of levels. Since the examples herein are text and thus form words (one level of final product) in a combination of spellings, the result of the word combinations in this embodiment of the invention is a phrase or sentence (another level of final product). Sentences can be combined to form phrases, and phrases can be combined to form chapters.

Depending on the variety of input, the final product may represent a different entity than words, sentences, phrases, and so on. As an example, if the input is a sequence of amino acids comprising a chromosome, one final product may represent a gene, or allele.

Consider the case where the input 204 has the following data record.

-Bill Tuesday 40 sold PA

-Bill Nonday 103 sold NJ

-Bill Monday 100 trial PA

-Tom Monday 80 sold PA

-Tom Monday 13 trial NJ

In one embodiment of the invention, the dataset elements consist of fields of information separated by delimiters, such as blank characters. In one embodiment, dataset elements are derived from input. However, the invention is not limited thereto. Thus, the dataset elements presented so far in the input data are: seller name (Bill and Tom), day of the week (Monday, Tuesday), number of items (40, 103, 100, 80, 13), status (sale, test), state (Pennsylvania) , New Jersey). In one embodiment, the interlocking tree datastore 1000 of FIG. 10 will be derived from this input. In FIG. 10, the first portion of the node is not shown. For example, although node 1002 is labeled "Bill", node 1002 represents the actual "BOT-Bill". Although node 1004 is represented as "Tuesday", node 1004 represents the actual "BOT-Bill-Tuesday".

Interlocking  tree From the datastore  Access information

A method of accessing information stored in an interlocking tree datastore is shown in FIG. In step 1102, a request is received to retrieve information from an interlocking tree datastore. The information retrieval request may be converted into a form that can be processed by an interlocking tree accessor. In step 1104, the indicated node is accessed. In step 1106, the appropriate as-case list and as-result list are retrieved. In step 1108, the desired information is retrieved along with the pointers of the appropriate aslist and aslistlist. In step 1110, the requested information is collected and output.

For example, referring to FIG. 7A, a datastore 700a that includes an Astrib link 328, 330, 332, 334, 710, 712, 714, 716 may read “A node contains the spelling 'A'. ? "," What is the spelling before or after 'A'? "," What word (or how many words) contains the letter 'A'? "," What word is spelled 'A' and 'T' Do you include both? "," What is the word that follows 'A' followed by 'T'? " It can be used to determine the answers to the context's questions, and so forth.

For example, in one embodiment of the invention, the node with the desired dataset element and the end products may be determined by following the pointers included in the aslist list of the particular node representing the dataset element. The access list is accessed, followed by each pointer of the list to an assense branch associated with the node. If the final product is desired, the ascase branch tree is followed by the leaf nodes of the branch.

In one embodiment of the invention, the information request is in the form of specifying a constraint. This can be viewed as "context" or "focus" depending on the point of view. For example, the request for information may appear in the form of a list of constraints. The list of constraints may be grouped or independent of each other. In one embodiment of the invention, an Aztrist list of each listed constraint is found, branches for each node in each Astristlist for each constraint are found, and the branches follow the final product. For each constraint, the intersection of the final products (ie, corresponding) for each branch in each Aslist list is selected. Grouping constraints are found by first constraining the datastore to import the dataset, which is then used as a dataset to be further constrained.

Logical operators can be used to specify constraints. Consider the case of finding nodes that identify people, places, and things. Where and are logical operators that specify the union of all people, places, and sets of things. That is, it would be a logical operator that specifies all nodes identified by an element or root node called "person", "place", and "thing". When asked for "person" and "place" for "thing" (another logical operator) , the interlocking tree structure will be constrained by an item called "thing." Interlocking tree structure When constructing a, if the thing does not point to a place, all other "things" will not be found in the query, but all the places known in the interlocking tree structure will be found. If people are considered to be things, they will also be found in the query.

Logical operators can take many forms, including AND, OR, NOT, GreaterThan, XNOR, EqualTo, and so on, and can be combined with each other. All such logical operators and combinations thereof are available within the present invention. Comparative equations may also be used in some cases. Finding all sellers who sold more than 100 cars can be a query based on a comparison equation. For example, the comparison equation would be a seller with a vehicle sales number of> 100.

In one embodiment of the invention, the focus determines the information that is output. In the case of a two-level datastore where the dataset elements are spelled out, if the level 1 final product contains words and the level 2 final product contains sentences, the specified constraint is a specific spelling, specifying that the focus is a "word". Will print only words, and if you specify the focus as "sentences" it will only print sentences. When the final product is loaded from the first level, words will be output. Thus, "focus" identifies the kind of information desired in the context. When the final product is loaded from the second level, sentences will be output. In one embodiment, to blow a sentence, an Azultist of each word follows to the next level, and the specified branch is followed by its final product to blow a sentence containing the specified spelling.

In one embodiment, by following a tree with a level start indicator as its root, one can find all the end products starting with one constraint. For example, you can find all words that start with a particular spelling. Likewise, you can find all end products with specific constraints, or all end products with specific constraints at a specific location. For example, you can find all words with a particular spell, or all words with a particular spell in a particular column. Similarly, by following the tree with the level end indicator as root, we can find all the end products that end with the specified constraints. For example, you might find a word that ends with a particular spelling. Multiple constraints and focus can be specified.

For example, consider the case where the first node of an ascase branch of a tree with a dataset element such as one spelling (eg, spelling "B") is desired. In one embodiment, an element root node (e.g., Node B 718) representing a data element is retrieved from memory and accessed to an alias list (e.g., an alias list 742f) to access the element. Outputs the locations of nodes created through the combination of the root node and some subcomponents. Access nodes in the Aslist list. In this example, location 180 is accessed. This position holds node BOT-T-A-B 707. Thus, node BOT-T-A-B 707 is a node of interlocking tree datastore 700a that contains a representation of the spelling "B". To find the final product formed, it follows the ascase branch by repeatedly invoking the ascaselist of the node being accessed until the imported ascaselist is null. For example, in this example, the branch has a node BOT-T 703, a node BOT-T-A 705, a node BOT-T-A-B 707, and a node BOT-T-A-B-EOT 709. For example, to determine that the word with dataset element B 718 is " TAB, " access the caselist 740f of node BOT-T-A-B 707 to retrieve location 185. Access the content at location 185 to retrieve the as-case list 748f. Since the case list 748f is a null pointer, the final product has been reached.

In FIG. 7A, consider the case where the first nodes of all ascase branches with the letter “A” are desired. Element root node A 304 is retrieved from memory, accesses its alias list 542f, and outputs positions 145 and 175. The first location 145 with node BOT-C-A 314 is accessed. Node BOT-C-A 314 is the first node of the first branch of data structure 700a containing spell A. To find the final product formed, follow the ascase branch's ascase links by repeatedly invoking the node's caselist until the imported caselist is null. In this example, the branch has a node BOT-C 312, a node BOT-C-A 314, a node BOT-C-A-T 316, and a node BOT-C-A-T-EOT 318. For example, to determine that the first word with dataset element A 304 is CAT, access caselist 740f of node BOT-C-A 314 to retrieve location 145. Access the contents of location 145 to invoke assistlist 532f 150. Access the contents of location 150 to invoke assist list 548f 155. The content at position 155 is accessed to retrieve the as-case list 572f. Since the case list 572f is a null pointer, the final product has been reached.

The next location 175 with node BOT-T-A 705 is accessed. Node BOT-T-A 705 is the first node of the second branch of interlocking tree datastore 700a that includes letter A. To find the final product formed, follow the ascase branch's ascase links by repeatedly invoking the node's caselist until the caselist is null. In this example, the branch has a node BOT-T 703, a node TOT-T-A 705, a node BOT-T-A-B 707, and a node BOT-T-A-B-EOT 709. For example, to determine that the second word with dataset element A 304 is “TAB,” access caselist 740f of node BOT-T-A-B 707 and retrieve location 185. Access the content at location 185 to retrieve the as-case list 748f. Since the case list 748f is a null pointer, the final product has been reached.

In FIG. 7A, consider the case where the first nodes of all ascase branches with the letters A and T are desired. As described above, the element root node A 304 is retrieved from the memory, the access list 542f is accessed, and the positions 145 and 175 are output. The first location 145 with node BOT-C-A 314 is accessed. Node BOT-C-A 314 is the first node of the first branch of data structure 700a containing spell A. To find the final product formed, follow the ascase branch's ascase links by repeatedly invoking the node's caselist until the imported caselist is null. In this example, the branch has a node BOT-C 312, a node BOT-C-A 314, a node BOT-C-A-T 316, and a node BOT-C-A-T-EOT 318. For example, to determine that the first word with dataset element A 304 is CAT, access caselist 740f of node BOT-C-A 314 to retrieve location 145. Access content at location 145 to invoke assistlist 532f 150. Access the contents of location 150 to invoke assist list 548f 155. The content at position 155 is accessed to retrieve the as-case list 572f. Since the case list 572f is a null pointer, the final product has been reached. The final product node BOT-C-A-T-EOT 318 has a dataset element A.

The next location 175 with node BOT-T-A 705 is accessed. Node BOT-T-A 705 is the first node of the second branch of interlocking tree datastore 700a that includes spell A. To find the final product formed, follow the ascase branch's ascase links by repeatedly invoking the node's caselist until the caselist is null. In this example, the branch has a node BOT-T 703, a node BOT-T-A 705, a node BOT-T-A-B 707, and a node BOT-T-A-B-EOT 709. For example, to determine that the second word with dataset element A 304 is “TAB,” access caselist 740f of node BOT-T-A-B 707 and retrieve location 185. Access the content at location 185 to retrieve the as-case list 748f. Since the case list 748f is a null pointer, the final product has been reached. The final product node BOT-T-A-B-EOT 709 has dataset element A.

Then, the element root node T 308 is retrieved from the memory, the access list 558f is accessed, and the positions 150 and 170 are output. First location 150 with node BOT-C-A-T 316 is accessed. Node BOT-C-A-T 316 is the first node of the first branch of data structure 700a containing the letter T. To find the final product formed, follow the ascase branch's ascase links by repeatedly invoking the node's caselist until the imported caselist is null. In this example, the branch has a node BOT-C 312, a node BOT-C-A 314, a node BOT-C-A-T 316, and a node BOT-C-A-T-EOT 318. For example, to determine that the first word with non-divisible element unit T 308 is CAT, access case list 532f of node BOT-C-A 314 is invoked to retrieve location 145. Access to the content at location 145 invokes as-case list 532f, 150. Access content at location 150 (node BOT-C-A-T 316) to invoke assistlist 548f. The content at position 155 is accessed to retrieve the as-case list 572f. Since the case list 572f is a null pointer, the final product has been reached. The final product node BOT-C-A-T-EOT 318 has a dataset element T.

The next location 170 with node BOT-T 703 is accessed. Node BOT-T 703 is the first node of the second branch of interlocking tree datastore 700a that includes the letter T. To find the final product formed, follow the ascase branch's ascase links by repeatedly invoking the node's caselist until the caselist is null. In this example, the branch has a node BOT-T 703, a node BOT-T-A 705, a node BOT-T-A-B 707, and a node BOT-T-A-B-EOT 709. For example, to determine that the second word with dataset element T 308 is "TAB", access caselist 740f of node BOT-T-A-B 707 and retrieve location 185. Access the content at location 185 to retrieve the as-case list 748f. Since the case list 748f is a null pointer, the final product has been reached. The final product node BOT-T-A-B-EOT 709 has a dataset element T. Thus, the final product with A and T includes the intersection of the final product set with A and the final product set with T. Or in the present case, carry BOT-C-A-T-EOT 318 and BOT-T-A-B-EOT 709.

In one embodiment of the invention, the imported information is displayed or printed. To display or print the imported information, it follows the case tree backwards from the final product to the point of view (BOT). At each node along the case tree, a result pointer is used to determine what the element root node represents. The result pointer points to the second part of the node. If an interlocking tree datastore contains more than one level, the result pointer must point to the last product at the lower level and follow the same process until the element root node at the lower level is called.

In Figure 10, consider the case where the total number of units sold on Tuesday is desired. Instead of traversing all nodes of the entire datastore in both directions, in one embodiment of the invention, retrieving this information requires retrieving only the results lists of element root nodes 1006 and 1008. Branch 5 1010 crosses in both directions because the element node representing Tuesday 1006 points to node 1004, and the element node representing sale 1008 points to node 1026. Branch 4 1012 crosses in both directions because the element node representing sale 1008 points node 1028. Branch 1 1015, branch 2 1014, branch 3 1013 need not cross. The intersection of the final product set output from the branches pointed to by the element nodes 1006 and 1008 is the node representing Bill Tuesday 40 sold PA (which means "Bill sells 40 on Tuesday" in Pennsylvania). 1030.

The number of units sold can be determined by following the pointers from node 1024 to the root node representing the number 40. This step can be executed after the intersection of the final product has been found, and this information can be retrieved and stored as the branch traverses in both directions.

Methods for evaluating a collection of data represented by an interlocking tree datastore having a count field, such as the count field of FIG. 12B, are described with reference to FIGS. 14A-E.

In FIG. 14A, task 40a is to evaluate some desired data from a datastore in an interlocking tree structure that we have discussed. To do this, we must determine the relevant context (40b). This is introduced in Figure 14b. The relevant context 41a begins by selecting 41b the desired value, where root nodes with this value are identified. Then all paths with only the selected value are found. In a preferred embodiment, step 41d, ignoring all paths with inconsistent values, is combined with step 41c in several ways, making the process more efficient. However, this combination will suitably depend on the type of data and values in the datastore. So it is shown here as a separate step.

After determining the context 40b, the next step is to determine 40c, focus or position, or both, depending on the nature of the query.

In FIG. 14D, the position is determined (step 42a) by finding the root node associated with the node value of the current position (step 42b).

In FIG. 14C, focus determination 40c is implemented by selecting a focus constraint list of values, thus identifying 43b relevant root nodes.

Returning to the context of FIG. 14E, all counts in the context that are not within the focus or position determined by the query before adding the count are ignored (44c).

The method and system described above may be embodied in the form of a program stored on a computer-readable medium, such as a floppy diskette, CD-ROM, DVD-ROM, DVD-RAM, hard disk drive, or other machine-readable storage medium. have. At this time, when the program code is loaded and executed by a machine such as a computer, the machine becomes an apparatus for implementing the present invention. The present invention can also be implemented in the form of program code transmitted over electrical wires or cables, over optical fibers, over a network (Internet, intranet, etc.), or through any other form of transmission medium. When the program code is received, loaded and executed by a machine such as a computer, the machine becomes an apparatus for implementing the invention. When implemented in a general purpose processor, the program code is combined with the processor to provide a unique apparatus that operates similarly to a particular logic circuit. Program code can be implemented in high-level programming languages such as C, C ++, and Java. Alternatively, program code may be implemented in assembly or machine language. In either case, the language can be a compiled or interpreted language.

Claims (24)

A system for generating a tree-based datastore, the system comprising: -Processor, Memory coupled to the processor, and A tree-based datastore generator for creating one or more levels of the tree-based datastore Wherein at least one level of the tree-based datastore comprises a first tree, a second tree, and a third tree, wherein the first tree comprises a first root and at least one node of a plurality of nodes. And the second tree includes a second route and the one or more nodes of the first route, and the third tree includes a third route and one or more nodes of the plurality of nodes of the first tree. Tree-based datastore generation system. A method of evaluating a collection of data represented by an interlocking tree datastore including nodes with links between nodes and a count field, the node comprising a root node, wherein the root node comprises one or more primary nodes. There is a root node and at least one elemental root node, the root node may comprise other root nodes, the root node being at least one end of a thought node, at least one subcomponent node, and at least one root node. And further includes the final product node, wherein there are as result and as case links, wherein the as result link points between the root node and other nodes, and the as case link is associated with one or more primary root nodes. Pointing between one or more end product nodes, Case link comprises a one or more subcomponents node in the path therebetween, the method comprising the steps of: Determine a context and its corresponding value in the datastore, Determine a focus and its corresponding value within the context, and Calculating a probability of occurrence of the focus in the context using the corresponding values of the context and the focus. And evaluating data collection. 3. The method of claim 2, wherein determining the context and its corresponding value comprises: Select a context constraint list of values of the interlocking tree datastore with values represented by one or more nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; Identify one or more paths by the last product node from the one or more root nodes by traversing from the results list of the one or more root nodes to the corresponding subcomponent nodes of the one or more root nodes, and Intersect ascase links between subcomponent nodes to each corresponding final product node of the subcomponent node, Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and Add a count of the last product node of one or more paths not ignored to obtain a context count And evaluating data collection. 3. The method of claim 2, wherein determining the context and its corresponding value comprises: Select a context constraint list of values of the interlocking tree datastore with values represented by one or more root nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; , Identifying one or more paths by the end product node, wherein the identification process is implemented by traversing backwards from the all possible end product nodes back to the primary route using a case link along the path, where each Determine the location of the root node at the subcomponent node of the node using the result link and compare the root node to the one or more root nodes, Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, and thus the set of derived nodes forming the context is not ignored. The node that follows the bay, and Add a count of the last product node of one or more paths not ignored to obtain a context count And evaluating data collection. A method of evaluating a collection of data represented by an interlocking tree datastore including nodes with links between nodes and a count field, the node comprising a root node, wherein the root node comprises one or more primary nodes. There is a root node and at least one elemental root node, the root node may comprise other root nodes, the root node being at least one end of a thought node, at least one subcomponent node, and at least one root node. And further includes the final product node, wherein there are as result and as case links, wherein the as result link points between the root node and other nodes, and the as case link is associated with one or more primary root nodes. Pointing between one or more end product nodes, Case link comprises a one or more subcomponents node in the path therebetween, the method comprising the steps of: Determine a context and its corresponding value in the dataset, Determine a location along each path within the context, Determine a focus and its corresponding value in the context, and Calculating a probability of occurrence of the focus between the position and the final product, along the path in the context. And evaluating data collection. The method of claim 5, wherein determining the location along each path of the context comprises: Selecting one root node from a root node or element root node of the interlocking tree datastore, and from the aslist list of the root node or element root node to its corresponding subcomponent node in each path of the context. Across And evaluating the data collection. 6. The method of claim 5, wherein determining the context and its corresponding value comprises: Select a context constraint list of values of the interlocking tree datastore with values represented by one or more nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; Identify one or more paths by the last product node from the one or more root nodes by traversing from the results list of the one or more root nodes to the corresponding subcomponent nodes of the one or more root nodes, and Crosses the case-link between subcomponent nodes to each corresponding final product node of the subcomponent node, Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and Add a count of the last product node of one or more paths not ignored to obtain a context count And evaluating data collection. 8. The method of claim 7, wherein determining the context and its corresponding value comprises: Select a context constraint list of values of the interlocking tree datastore with values represented by one or more root nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; , Identifying one or more paths by the end product node, wherein the identification process is implemented by traversing backwards from the all possible end product nodes back to the primary route using a case link along the path, where each Determine the location of the root node at the subcomponent node of the node using the result link and compare the root node to the one or more root nodes, Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and Add a count of the last product node of one or more paths not ignored to obtain a context count And evaluating data collection. A method of evaluating a collection of data represented by an interlocking tree datastore including nodes with links between nodes and a count field, the node comprising a root node, wherein the root node comprises one or more primary nodes. There is a root node and at least one elemental root node, the root node may comprise other root nodes, the root node being at least one end of a thought node, at least one subcomponent node, and at least one root node. And further includes the final product node, wherein there are as result and as case links, wherein the as result link points between the root node and other nodes, and the as case link is associated with one or more primary root nodes. Pointing between one or more end product nodes, Case link comprises a one or more subcomponents node in the path therebetween, the method comprising the steps of: Determine a context and its corresponding value in the dataset, Determine a location along each path within the context, Determine a focus and its corresponding value in the context, and Calculating a probability of occurrence of the focus between the location and the primary root, along the path in the context And evaluating data collection. 10. The method of claim 9, wherein determining the location along each path of the context includes: Selecting one root node from a root node or element root node of the interlocking tree datastore, and from the aslist list of the root node or element root node to its corresponding subcomponent node in each path of the context. Across And evaluating the data collection. 10. The method of claim 9, wherein determining the context and its corresponding value comprises: Select a context constraint list of values of the interlocking tree datastore with values represented by one or more nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; Identify one or more paths by the last product node from the one or more root nodes by traversing from the results list of the one or more root nodes to the corresponding subcomponent nodes of the one or more root nodes, and Intersect ascase links between subcomponent nodes to each corresponding final product node of the subcomponent node, Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and Add a count of the last product node of one or more paths not ignored to obtain a context count And evaluating data collection. 10. The method of claim 9, wherein determining the context and its corresponding value comprises: Select a context constraint list of values of the interlocking tree datastore with values represented by one or more root nodes, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression; , Identifying one or more paths by the end product node, wherein the identification process is implemented by traversing backwards from the all possible end product nodes back to the primary route using a case link along the path, where each Determine the location of the root node at the subcomponent node of the node using the result link and compare the root node to the one or more root nodes, Ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression, so that the set of derived nodes forming the context only follows the path that is not ignored. The node, and Add a count of the last product node of one or more paths not ignored to obtain a context count And evaluating data collection. 10. The method of claim 9, wherein determining the context and its corresponding value comprises: Select all possible paths by the final product node of the interlocking tree datastore and ignore paths with links to element root nodes, where the value fields of the path do not match the logical expression and thus The set of derived nodes that form the context includes nodes that follow only the paths that are not ignored, and Get a context count and add a count of the final product nodes of one or more paths not discarded And evaluating the data collection. 13. The method of any of claims 2, 5, 9 and 12, wherein determining the focus and its corresponding value comprises: Select a focus constraint list of one or more root nodes from a root node or element root node of the interlocking tree datastore, wherein the one or more root nodes are associated with each other by a logical expression; The one or more roots as a traversal from the aslist list of the one or more root nodes to any corresponding subcomponent, and the ascase link of the corresponding subcomponent node to its corresponding final product node; Identifies one or more paths from the node by the end product node, Ignore paths that are not in the built context, and Also ignore paths with links to element root nodes with value fields that do not match the above logical expression, so that the set of derived nodes that form the focus include nodes that follow only non-ignored paths; , And Add a count of the last product node of one or more paths forming the focus to obtain a focus count And evaluating data collection. The method of any one of claims 2, 5, 9 and 12, wherein the determining of the focus and its corresponding value comprises: Select a focus constraint list of one or more root nodes from the root node or element root node of the interlocking tree datastore, wherein the one or more root nodes are associated by a logical expression and represented by one or more root nodes Select a context constraint list having the following values, wherein all of the one or more root nodes on the context constraint list are associated with each other by a logical expression, Identifying one or more paths by the final product node, wherein the identification process is implemented by traversing backwards along the path from all final product nodes in the established context towards the primary root node, wherein The path is identifiable using the case link of the last product node in the established context, wherein at each subcomponent node, the location link is used to determine the location of the root node and route the root node to the one or more roots. To nodes, Derived sets of nodes that ignore paths with links to element root nodes with value fields that do not match the above logical expression, and thus form focus, include nodes that follow only paths that are not ignored, And -Add a count of the last product node of one or more paths that are not ignored to get the focus count. And evaluating data collection. The method of any one of claims 4, 6, 7, 8, 9, 11, 12, 14, wherein the logical expression is one or more logical operators including any one of AND, OR, NOT, GREATERTHAN, LESSTHAN, XNOR, EQUALTO And any combination of the logical operators. A node having a link between nodes, wherein the nodes have a plurality of data fields, two or more of the plurality of fields having a pointer, one of the two or more pointers being a case pointer, and the two or more pointers. The other one is a result pointer, wherein one or more nodes have one or more additional pointers to the list of pointers, and one of the additional pointers to the pointer list is an case in the case where the node has an associated ascase list. A pointer to a list, the other of the additional pointers is a pointer to an Aslist list in the case where the node has an Aslist list, The node has a count field, the node including a root node, at least one primary root node and at least one elemental root node, wherein the node may include other root nodes, The node comprises at least one end of a thought node, at least one subcomponent node, and at least one final product node, wherein the as links are pointing between a root node and other roots, and the as The case link points between one or more primary root nodes and one or more end product nodes, wherein the as case link includes one or more subcomponent nodes in the path therebetween, and the associative link includes a root or end product node. Between a subcomponent node and a final product node And wherein said element node comprises a field having a single value. 18. The structure of claim 17, wherein the structure is formed from a set of program instructions that, when activated to create the structure, establish a computer system. A computer readable medium having a program instruction set according to claim 18. 18. The node and node of claim 17, wherein the count field has an intensity variable, the intensity variable being modifiable to various intensities corresponding to various specified kinds of activities related to the node having the count field. Structure containing a link. 18. The system of claim 17, wherein the ascase and aslist lists are stored in a data structure separate from the interlocking tree structure, the separated data structure being associated with a related node in the interlocking tree structure by a pointer. Structure characterized in that. A structure with nodes and links between nodes, The nodes have a plurality of data fields, two or more of the plurality of fields having a pointer, one of the two or more pointers being a case pointer, the other of the two or more pointers being a resort pointer, one or more The node has one or more additional pointers to the list of pointers, one of the additional pointers to the pointer list being a pointer to an ass list in the case where the node has an associated ascase list, the other of the additional pointers. One is a pointer to an Aslist list in the case where the node has an Aslist list, Each of the nodes is provided with one subnode for traversing a specified manner, the subnode having a count field for recording traversing the node in a specified manner, the node comprising a root node, Among them there is at least one primary root node and at least one elemental root node, the node may comprise other root nodes, the node being at least one end of a thought node, at least one subcomponent. A node and one or more final product nodes, wherein the as links link between a root node and other routes, and the ascase links point between one or more primary root nodes and one or more final product nodes, and The at least one case link may be one or more subcomponent nodes. Included in the path therebetween, the As links link between the root or final product node and the subcomponent node or the final product node, wherein the element node has a field with a single value. A structure containing nodes and links between nodes. A node having a link between nodes, wherein the nodes have a plurality of data fields, two or more of the plurality of fields having a pointer, one of the two or more pointers being a case pointer, and the two or more pointers. The other one is a result pointer, wherein one or more nodes have one or more additional pointers to the list of pointers, and one of the additional pointers to the pointer list is an case in the case where the node has an associated ascase list. A pointer to a list, the other of the additional pointers is a pointer to an Aslist list in the case where the node has an Aslist list, The node has an additional field, the node including a root node, at least one primary root node and at least one elemental root node, the node may comprise other root nodes, The node comprises at least one end of a thought node, at least one subcomponent node, and at least one final product node, wherein the as links are pointing between a root node and other roots, and the as The case link points between one or more primary root nodes and one or more end product nodes, wherein the as case link includes one or more subcomponent nodes in the path therebetween, and the associative link includes a root or end product node. Between the subcomponent node and the final product node And the element node comprises a field having a single value. 24. The structure of claim 23, wherein the additional field is a count field.

Images