Title of Invention  A METHOD OF COMPARING THE CLOSENESS OF A TARGET TREE TO OTHER TREES USING NOISY SUBSEQUENCE TREE PROCESSING 

Abstract  The present invention provides a method of comparing the closeness of a target tree to other trees located in a database of trees, said method comprising the steps of (a) calculating a constraint in respect of each tree in the database based on an estimated number of edit operations and a characteristic of the target tree (b) calculating a constrained tree edit distance between the target tree and each tree in the database using the constrained obtained in step (a); and (c) comparing the calculated constrained tree edit distances. The method of this invention can also be applied to matching a target tree representable structure to its closest tree representable structure. 
Full Text  A METHOD OF COMPARING THE CLOSENESS OF A TARGET TREE TO OTHER TREES USING NOISY SUBSEQUENCE TREE PROCESSING Field Of the Invention The present invention relates to methods for pattern recognition, wherein the identity of the parent can be determined from a "noisy" fragment thereof. Subject matter that is identifiable by this method is such that it can be represented by a tree notation. Background Of the Invention The need to identify the parent of a subfragment arises frequently in a variety of fields ranging from engineering and medicine to electronics, computer science, physics, chemistry and biology. In most of the cases the problem is computationally intractable since the number of variables involved as a consequence of the degrees of uncertainty, renders the calculations impossible. This situation is aggravated by the common occurrence that the integrity of the subfragment may be compromised in some way. Typically, when the pattern to be recognized is inherently a "twodimensional" structure, it cannot be adequately represented using a onedimensional (string or circular string) approximation. By representing the pattern as a tree and by utilizing tree comparison algorithms one can, generally speaking, achieve excellent recognition strategies. Indeed, such schemes have been utilized in Pattern Recognition (PR) in areas such as clustering by Lu (IEEE Trans. Pattern Anal, and Mach. Intell., PAMI 1, pp. 219224 (1979)) and by Cheng and Lu in waveform correlation (IEEE Trans. PAMI, PAMI 7, pp. 299305 (1985)). However, when the pattern to be recognized is occluded and only noisy information of a fragment of the pattern is available, the problem encountered can be mapped onto that of recognizing a tree by processing the information in one of its noisy subtrees or subsequence trees. Trees are a fundamental data structure in computer science. A tree is, in general, a structure which stores data and it consists of atomic components called nodes and branches. The nodes have values which relate to data from the real world, and the branches connect the nodes so as to denote the relationship between the pieces of data resident in the nodes. By definition, no edges of a tree constitute a closed path or cycle. Every tree has a unique node called a "root". The branch from a node toward the root points to the "parent" of the said node. Similarly, the branch of the node away from the root points to the "child" of the said node. The tree is said to be ordered if there is a lefttoright ordering for the children of every node. Trees have numerous applications in various fields of computer science including artificial intelligence, data modeling, pattern recognition, and expert systems. In all of these fields, the trees structures are processed by using operations such as deleting their nodes, inserting nodes, substituting node values, pruning subtrees from the trees, and traversing the nodes in the trees. When more than one tree is involved, operations that are generally utilized involve the merging of trees and the splitting of trees into multiple subtrees. In many of the applications which deal with multiple trees, the fundamental problem involves that of comparing them. Trees, graphs, and webs are typically considered as a multidimensional generalization of strings. Among these different structures, trees are considered to be the most important "nonlinear1 structures in computer science, and the treeediting problem has been studied since 1976. Similar to the stringediting problem , (see: D. Sankoff and J. B. Kruskal, Time wraps, string edits, and macromolecules : Theory and practice of sequence comparison, AddisonWesley (1983); R. A. Wagner and M. J. Fischer, /. Assoc. Comput Mach., 21:168173, (1974); B. J. Oommen and R. L. Kashyap, Pattern Recognition, 31, pp. 11591177 (1998); P. A. V. Hall and G. R. Dowling, Comput. Sur., 12 : pp 381402 (1980) ; R. L. Kashyap and B. J. Oommen, Intern. J. Computer Math., 13 : pp 1740 (1983); R. Lowrance and R. A. Wagner, /. ACM, 22: pp 177183 (1975)), the treeediting problem concerns the determination of the distance between two trees as measured by the minimum cost sequence of edit operations. Typically, the edit sequence considered includes the substitution, insertion, and deletion of nodes needed to transform one tree into the other. Unlike the stringediting problem, only few results have been published concerning the treeediting problem. In 1977, Selkow (Jnform. Process. Letters, 6(6):184186, (1977)) (see also Sankoff and J. B. Kruskal, Time wraps, string edits, and macromolecules : Theory and practice of sequence comparison, AddisonWesley (1983)) presented a tree editing algorithm in which insertions and deletions were only restricted to the leaves. Tai {J. Assoc. Comput. Mach., 26:422433 (1979)) in 1979 presented another algorithm in which insertions and deletions could take place at any node within the tree except the root. The algorithm of Lu (JEEE Trans. Pattern Anal, and Mach. Intell, PAMI l(2):219224 (1979)) on the other hand, did not solve this problem for trees of more than two levels. The best known algorithm for solving the general treeediting problem is the one due to Zhang and Shasha (SIAMJ. Comput.,18(6):12A51262 (1989)). Also, in all the papers published till the mid90's, the literature primarily contains only one numeric intertree dissimilarity measure  their pairwise "distance" measured by the minimum cost edit sequence. The literature on the comparison of trees is otherwise scanty : Shapiro and Zhang (CompuL Appl Biosci. vol. 6, no. 4, 309318, (1990)) has suggested how tree comparison can be done for ordered and unordered labeled trees using tree alignment as opposed to the edit distance utilized elsewhere (Zhang and Shasha (1989) supra). The question of comparing trees with variable length don't care edit operations was also solved by Zhang, Shasha and Wang {Proceedings of the 1992 Symposium on Combinatorial Pattern Matching, CPM92:148161, (1992)). Otherwise, the results concerning unordered trees are primarily complexity results : Zhang, etai, {Information Processing Letters, 42:133139, (1992)) showed that editing unordered trees with bounded degrees is NPhard, and even MAX SNPhard by Zhang and T. Jiang, information Processing Letters, 49:249254 (1994)). The most recent results concerning tree comparisons are probably the ones due to Oommen, Zhang and Lee (JEEE Transactions on Computers, TC45:14261434, (1996)) In this publication, the authors defined and formulated an abstract measure of comparison, &(Tl, T2), between two trees Ti and T2 presented in terms of a set of elementary intersymbol measures ©(.,.) and two abstract operators. By appropriately choosing the concrete values for these two operators and for ©(.,.)> the measure Cl was used to define various numeric quantities between Ti and T2 including (i) the edit distance between two trees, (ii) the size of their largest common subtree, (iii) Prob(T2Ti), the probability of receiving T2 given that Ti was transmitted across a channel causing independent substitution and deletion errors, and, (iv) the a posteriori probability of Ti being the transmitted tree given that T2 is the received tree containing independent substitution, insertion and deletion errors. Unlike the generalized tree editing problem, the problem of comparing a tree with one of its possible subtrees or Subsequence Trees (SuTs) has almost not been studied in the literature at all. The only reported results for comparing trees in this setting have involved constrained tree distances and are due to Oommen and Lee, information Sciences, Vol. 77 No. 3,4:253273 (1994)) and Zhang, (Proceeding ofthelASTED International Symposium , New York, pp. 9295 (1990)). SUMMARY OF THE INVENTION In one embodiment, this invention provides a method of comparing the closeness of a target tree to other trees located in a database of trees, said method comprising the steps of: (a) calculating a constraint in respect of each tree in the database based on an estimated number of edit operations and a characteristic of the target tree; (b) calculating a constrained tree edit distance between the target tree and each tree in the database using the constraint obtained in step (a); and (c) comparing the calculated constrained tree edit distances. In another embodiment, this invention provides a method of matching a target tree representable structure to its closest tree representable structure, said method comprising the steps: (a) generating one or more target trees for a target structure; (b) calculating a constraint in respect of each tree in the database based on an estimated number of edit operations and a characteristic of the target tree; (c) calculating a constrained tree edit distance between the target tree and each tree in the library using the constraint obtained in step (b) and the intersymbol edit distance; (d) comparing the calculated constrained tree edit distances; and (e) reporting the tree in the database that has the smallest constrained tree distance. The method of this invention comprises a series of nested algorithms. A schematic representation of the overall algorithm is presented in Figure 8. This algorithm invokes algorithms for each of which schematic representations are presented in Figures 9 18. Brief Description Of The,Figures Figure 1 presents an example of a tree X*, U, one of its Subsequence Trees, and Y which is a noisy version of U. The Noisy Subsequence Tree (NSuT) Recognition problem involves recognizing X* from Y. Figure 2 presents an example of the insertion of a node in a tree. Figure 3 presents an example of the deletion of a node in a tree. Figure 4 presents an example of the substitution of a node by another in a tree. Figure 5 presents an example of a mapping between two labeled ordered trees. Figure 6 demonstrates a tree from the finite dictionary H. Its associated list representation is as follows: ((((t)2)(((j)s)(t)(u)(v)x)a)((f)(((u)(v)a)(b)((p)c)g)c)(((i)(((q)(r)g)j)k)s)((x)(y)(z)e)d) Figure 7 presents the lefttoright postorder tree representation of a list obtained from a string. String Represented: inthissectionwecalculatetheapos. TreeRepresented: (((((((((((i)n)t)h)((i)s)s)e)c)t)((((((i)o)((n)w)e)c)a)((((I)c)((u)l)(((a)t)e)t)h)e)a)p)o)s) Figure 8 presents a schematic diagram showing the Process RecognizeSubsequenceTrees used to solve the Noisy Subsequence Tree Recognition Problem. The input comprises (1) the finite dictionary, H, (2) Y, a noisy version of a subsequence tree of an unknown X* in H, and (3) L, the expected number of substitutions in Y. The output comprises the estimate X+ of X*. If L is not a feasible value L,, is the closest feasible integer. The set of elementary edit distances (d(.,.)} is assumed global. Figure 9 is a schematic diagram showing the Process Constrained_Tree_Distance. The input comprises the array Const_T_Wt[.,.,.] computed using Process T_Weights and constraint x given as a set of the number of substitutions used in the constrained editing process. The output comprises the constrained distance DT(T,, T2). Figure 10 is a schematic diagram showing the Process T_Weights. The input coniprises Trees T, and T2 and the Set of Elementary Edit Distances. The output comprises Const_T_Wt(i, j, s), for l£ i Figure 11 is a schematic diagram showing the Process Preprocess_For_TWeights. The input comprises Trees T, and T2. The outputs are the 8[] and Essential_NodesQ for both trees. Figure 12 is a schematic diagram showing the Process Compute_Const_T_Wt. The input comprises the indices i, j and the quantities assumed global in T_Weights. The output comprises the array Const_TWt[ i, j,,s], 8,(0 £ i, Figure 13 is a schematic diagram showing the steps of the Process ComputeConstTJIVt subsequent to those shown in Figure 12. Figure 14 is a schematic diagram showing the steps of the Process ComputeConstTWt subsequent to those shown in Figure 13. Figure 15 is a schematic diagram showing the steps of the Process Compute_Const_T_Wt subsequent to those shown in Figure 14. Figure id is a schematic diagram showing the steps of the Process ComputeConstTWt subsequent to those shown in Figure 15. Figure 17 is & schematic diagram showing the steps of the Process Compute_Const_T_Wt subsequent to those shown in Figure 16. Figure 18 is a schematic diagram showing the steps of the Process Compute_Const_T_Wt subsequent to those shown in Figure 17. Figure 19 is a schematic diagram showing how the invention can be used in the recognition of Ribonucleic Acids (RNA) molecules from their noisy fragments. Since an RNA molecule can be directly represented as a tree structure, the recognition of the RNA molecule from its fragment is a straightforward application of the solution to the NSuT problem. Figure 20 is a schematic diagram showing how the invention can be used in the recognition of chemical compounds, represented in terms of their molecules, from their noisy fragments. Since chemical compounds are drawn as graphs, each compound is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the compound is also mapped into a set of representative tree structures. The compound recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each compound and the tree representations of the noisy fragment. Figure 21 is a schematic diagram showing how the invention can be used in the recognition of chemical compounds, represented in terms of their atomic structure, from their noisy fragments. Since chemical compounds are drawn as graphs, each compound is first mapped into a set of representative tree structures, where the nodes are the atoms. Similarly, the noisy fragment of the compound is also mapped into a set of representative tree structures. The compound recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each compound and the tree representations of the noisy fragment. Figure 22 is a schematic diagram showing how the invention can be used in the recognition of fingerprints. As is well known in the field of fingerprint recognition, the fingerprints are characterized by their minuatae. The recognition is achieved from a noisy portion of the fingerprint sought for. Since numerous minuatae representations of each fingerprints are possible, each fingerprint is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the fingerprint is also mapped into a set of representative tree structures. The fingerprint recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each fingerprint and the tree representations of the noisy fragment Figure 23 is a schematic diagram showing how the invention can be used in the recognition of maps. The recognition is achieved from a noisy portion of the map sought for. Since numerous tree representations of each map are possible, each map is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the map sought for is also mapped into a set of representative tree structures. The map recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each map and the tree representations of the noisy fragment. Figure 24 is a schematic diagram showing how the invention can be used in the recognition of electronic circuitry. The recognition is achieved from a noisy portion of an electronic circuit sought for. The nodes in this case are the various electronic components such as resistors, diodes, transistors, capacitors etc. Since numerous tree representations of each electronic circuit are possible, each electronic circuit is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the electronic circuit sought for is also mapped into a set of representative tree structures. The electronic circuitry recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each electronic circuit and the tree representations of the noisy fragment. Figure 25 is a schematic diagram showing how the invention can be used in the recognition of flow charts. The recognition is achieved from a noisy portion of a flow chart sought for. The nodes in this case are the various symbols used in flow charting such as assignments, loops, comparisons, control structures etc. Since numerous tree representations of each flow chart are possible, each flow chart is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the flow chart sought for is also mapped into a set of representative tree structures. The flow chart recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each flow chart and the tree representations of the noisy fragment. Figure 26 presents the "confusion matrix" (Table I) with the probabilities of substituting a character with another character. The figures in the table are to be multiplied by a factor of 10'3. Figure 27 presents Table II displaying examples of the original trees, the associated subsequence trees and their noisy versions. Figure 28 presents Table III, describing a subset of the trees used for Data Set A and their noisy subsequence trees. The trees and subsequence trees are represented as parethensized lists. Figure 29 presents Table VI, describing a subset of the trees used for Data Set B and their noisy subsequence trees. The trees and subsequence trees are represented as parenthesized lists. The original unparenthesized strings are the same as those used in Oommen, IEEE Trans. Pattern Anal. And Mach. Intell., Vol. PAMI 9, No. 5:676685, (1987) and were obtained from Hall and Dowling, Comput Sur., Vol 12:381402 (Dec 1980). Figure 30 presents a typical example of a bacterial phylogenetic tree displaying the differences between Bacteria and Archaea. Detailed description Of The Invention This invention provides a method of comparing the closeness of a target tree to other trees, wherein the target tree can optionally be a noisy subfragment of the other trees. The tree is provided by a user and the trees to be compared are located in a database. The invention utilizes the process of constrained tree editing to tree structures derived from the target tree and at least one tree representation of every structure stored in the database. The method can also be applied to strings, wherein a string is considered a tree in which each parent node has exactly one child. The method of this invention is based on the assumption that there is some connection between the target tree and one or more trees located in the database. The target could be unrelated, but similar, it could be a subfragment of a parent tree located in the database, or it could be a noisy subfragment of a parent located in the database. Moreover, since a string can be considered as a tree in which each parent node as exactly one child, the method can also be applied to string problems by representing the string as a tree. The versatility of the method of this invention derives from the fact that the Noisy Subsequence Tree Recognition problem is applied in each of these circumstances to compare the closeness of a target tree to other trees located in a database of trees. In one embodiment, this invention provides a method of comparing the closeness of a target tree to other trees located in a database of trees, said method comprising the steps of: (a) calculating a constraint in respect of each tree in the database based on an estimated number of edit operations and a characteristic of the target tree; (b) calculating a constrained tree edit distance between the target tree and each tree in the database using the constraint obtained in step (a); and (c) comparing the calculated constrained tree edit distances. In another embodiment, this invention provides a method of matching a target tree representable structure to its closest tree representable structure, said method comprising the steps: (a) generating one or more target trees for a target structure; (b) calculating a constraint in respect of each tree in the database based on an estimated number of edit operations and a characteristic of the target tree; (c) calculating a constrained tree edit distance between the target tree and each tree in the library using the constraint obtained in step (b) and the intersymbol edit distance; (d) comparing the calculated constrained tree edit distances; and (e) reporting the tree in the database that has the smallest constrained tree distance. This method has widespread applications for any subject matter that can be depicted as a tree, which applies to tree representable structures as diverse as ribonucleic acid (RNA) chemical formulae, electronic circuitry, architectural plans, geographic maps, fingerprint records, engineering drawings, etc. Since numerous tree representations of each item are possible, each item is first mapped into,a set of representative tree structures. These tree representations are stored in a database means. If the method is applied to a situation in which the target tree is a noisy fragment of a parent tree, located in a database, the noisy fragment of the item sought for is also mapped into a set of representative tree structures. The overall pattern recognition is achieved by invoking the solution to the NsuT problem between the various tree representations of each item and the tree representations of the noisy fragment for which the parent identity is being sought. Since the graphtotree manipulations are straightforward, the key of the invention involves the solution of the Noisy Subsequence Tree Recognition Problem described below which involves recognizing a tree, X*, which is an element of a dictionary or database of trees. The latter recognition is achieved by processing the information contained in a tree, Y, which in turn, is a noisy (garbled or inexact) version of U, one of subsequence trees of X*. Since Y is a noisy version of an arbitrary subsequence tree of X*, (and not a noisy version of X* itself), clearly, just as in the case of recognizing noisy subsequences from strings (see Oommen (JEEE Trans. Pattern Anal. and Mack Intell, PAMI9, No. 5 : pp. 676685 (1987))), it is meaningless to compare Y with all the trees in the dictionary themselves, even though they are potential sources of Y. The fundamental drawback in such a comparison strategy is the fact that significant information was deleted from X* even before Y was generated, and so Y should rather be compared with every possible subsequence tree of every tree in the dictionary. Clearly, this is intractable, since the number of SuTs of a tree is exponentially large and so an alternative way of comparing Y with every X in H has to be devised. Before comparing Y to the individual tree in H, the additional information obtainable from the noisy channel will have to be used. Also, since the specific number of substitutions (or insertions/deletions) introduced in any specific transmission is unknown, it is reasonable to compare any X e H and Y subject to the constraint that the number of substitutions that actually took place is its best estimate. Of course, in the absence of any other information, the best estimate of the number of substitutions that could have taken place is indeed its expected value, L, which is usually close to the size of the NSuT, Y. One could therefore use the set {L} as the constraint set to effectively compare Y with any X € H. Since the latter set can be quite restrictive, a constraint set which is a superset of {L} marginally larger than {L} is suggested. Indeed, one such superset used for the experiments reported in this document contains merely the neighbouring values, and is {Ll, L, L+l}. Since the size of the set is still a constant, there is no significant increase in the computation times. Oommen (JEEE Trans. Pattern Anal and Mach. Intell, PAMI 9: pp. 676685 (1987)) devised an algorithm for the recognition of noisy subsequence from strings, which was achieved by evaluating the interstring constrained edit distance. The results reported for solving the NsuT problem are not mere extensions of the corresponding string editing and recognition problem. This is because, unlike in the case of strings, the topological structure of the underlying graph prohibits the twodimensional generalizations of the corresponding computations. Indeed, intertree computations require the simultaneous maintenance of metatree considerations represented as the parent and sibling properties of the respective trees, which are completely ignored in the case of linear structures such as strings. This further justifies the intuition that not all "string properties" generalize naturally to their corresponding "tree properties". In contrast, however, the present invention has vast and enormous applications in problems which involve strings, substrings and subsequences. The current invention, as it has been presented here addresses the problem of recognizing trees by processing the information resident in their (noisy) subsequence trees. But if it is observed that a string is itself a tree in which each parent node has exactly one child, the current invention can be directly applied to the corresponding problems involving strings. Although the mappings between the problems from the treedomain to the stringdomain are straightforward, the following examples (in postorder notation) are catalogued so as to clarify their instantiations. For example, consider the string recognition problem. Recognizing the string "approximately" by processing the information in the noisy string "approfshrtely", can be achieved by recognizing the postorder tree "(((((((((((((a)p)p)r)o)x)i)m)a)t)e)l)y)w by processing the information in the postorder tree a((((((((((((a)p)p)r)o)f)s)h)r)t)e)l)y)" using the method for NSuT recognition introduced here. In another example, consider the substring recognition problem. Recognizing the string "approximately" by processing the information in the noisy substring "approf', can be achieved by recognizing the postorder tree "(((((((((((((a)p)p)r)o)x)i)m)a)t)e)l)y)" by processing the information in the postorder subtree "((((((a)p)p)r)o)f)w using the method for NSuT recognition introduced here. In yet another example, consider the substring recognition problem. Recognizing the string "approximately" by processing the information in the noisy subsequence "appxiftxy", can be achieved by recognizing the postorder tree "(((((((((((((a)p)p)r)o)x)i)m)a)t)e)l)y)" by processing the information in the postorder subsequence tree "(((((((((a)p)p)x)i)f)t)x)y)" using the method for NSuT recognition introduced here. It is thus clear that the present invention, essentially represents a single generic solution for all (noisy) string, substring and subsequence recognition algorithms, while it simultaneously can be used as a generic solution to all (noisy) tree, subtree and subsequence tree recognition problems. Description of Tree Representable Structures The invention pertains to the recognition of subject matter which can be described as a planar or nonplanar graph in two dimensions using nodes and edges. Items constituting such subject matter are called Tree Representable Structures. A "tree representable structure", as referred to herein, is any structure which can be represented using nodes and edges in a tree structure. Each item of this subject matter can be represented in a tree structure by extracting from the graph an underlying spanning tree as explained in Aho et al (The Design and Analysis of Computer Algorithms, Addison Wesley, Reading : MA, (1974)) and by Cormen et al (Jntroduction to Algorithms, The MIT Press, Cambridge : MA, (1989)). The items do not need not be two dimensional. Rather, they must be representable as twodimensional graphs which may be planar or nonplanar. Once a database comprising such (extracted) tree structures is constructed, the parent of any "noisy" fragment of any of these tree structures can be identified using the method of this invention. Examples of items that can be described in twodimensions are maplike structures such as RNA molecules or parts thereof, plans, designs, chemical compounds described in their molecular structures, chemical compounds described in their atomic structures, drawings, electronic circuits, fingerprints, and flowcharts. The recognition of all of these items in their particular application domain utilizes the solution of the Noisy Subsequence Recognition (NsuT) problem described presently, which indeed constitutes a central kernel of the invention. A twodimensional tree representation is readily generated from a general pattern, or structure. First the characteristic features of the pattern, or structure, are identified. Second, certain of these features are identified as nodes and others as edges and subsequently organized to form a representative twodimensional tree. For example, using the application domain involving fingerprints, given the original fingerprint, a preprocessing system would typically extract the characterizing features which would be used in the recognition. The features in this application domain are referred to as the minutiae. The relationship between the minutiae can be represented using edges. The resulting structure is a tree in which the nodes are the minutiae themselves and the edges represent the proximity between them. A pattern would be stringrepresentable if the pattern can be described as a sequence of individual symbols in a lefttoright manner or a righttoleft manner. If, apart from such a linear description, the sequence of symbols also possesses a parentchild relationship, the pattern is treerepresentable. It should be observed that whereas a stringrepresentable pattern obeys a sibling property between the symbols, a treerepresentable pattern would additionally possess both a sibling property and a parentchild property. Generating a Tree for a Graph Structured Item A graph is a twodimensional structure consisting of nodes (also called vertices) and edges. The edges can be represented as lines between the nodes. Each node possesses a node content which consists of its identity and a value that it contains. The graph can be stored in terms of its adjacency matrix, which is a twodimensional matrix which has an entry in its position to indicate that there is an edge between nodes i and j. The graph can alternatively be stored in terms of an adjacency list for every node, which list is a onedimensional list stored for every node. The list for node i has an entry j to indicate that there is an edge between nodes i and j in the graph. Obtaining a tree structure from a graph is a straightforward and fundamental task in computing as explained in Aho et al. {The Design and Analysis of Computer Algorithms, Addison Wesley, Reading : MA, (1974)) and by Cormen et al (Introduction to Algorithms, The MIT Press, Cambridge : MA, (1989)). Such a tree is called a spanning tree. The details of a computation yielding a spanning tree are omitted as they can be found in any fundamental textbook in computer science are well known in the field. The method is briefly outlined as follows. A preferred method for deriving a spanning tree from a graph entails starting from an arbitrary node, (for example, i.) and mark it as a "visited" node. The method would then recursively visit all the adjacent nodes of the most recently visited node, which have not been marked "visited" yet, and retain the edge between them. The tree would consist of the entire set of nodes and the retained edges. Note that various tree representations of a graph are possible depending on the starting node and the sequence in which the nodes adjacent to a "visited" node are themselves "visited". Trees can be generated for different perspectives of subject matter that is a threedimensional structure. Obviously this factor could generate an almost infinite number of permutations for comparing a target tree to the database of trees. This problem can be addressed by considering that the problem of determining an appropriate tree representation for a treerepresentable structure is problem dependant. It is by no means trivial. Since each item can be mapped into numerous spanning trees, and each target can, in turn, be mapped into numerous spanning trees, the optimal recognition based on the criteria of minimizing the constrained edit distance would involve a tree representation of the target item to all the tree representations of the items. Since the number of tree representations of the item is prohibitively large, it is therefore expedient to use just a representative set of socalled perspective trees for each pattern. The subset of trees that can be chosen to represent an item can be chosen using any criterion. One criterion could be to use the representation which are most "stringy"  in which each node has the minimum number of children. Other criteria could involve the representation that is the maximum/minimum spanning tree of the graph, where the edgeweights could be the functions of the node values themselves. An alternate method for achieving the pattern recognition would be that of comparing a single tree representation of the target with a small subset of tree representations of the items. If the associated constrained distance between a tree representation of a item and the representation of the target is greater than a userspecified threshold value, the computation would request for a new tree representation of the target. The Noisy Subsequence Tree Recognition Problem To demonstrate the NSuT Recognition problem, let Y be a NsuT and X be any arbitrary element of the database means, also called the dictionary, H. Generating the Data Structure Representation of the Dictionary Generating a dictionary from a set of tree structures is a straightforward task which is well known to one skilled in the art, and which involves storing the trees in their lefttoright postorder parenthesized representations as explained in Aho et al {The Design and Analysis of Computer Algorithms, Addison Wesley, Reading : MA, (1974)) and by Cormen et al. introduction to Algorithms, The MIT Press, Cambridge : MA, (1989). A tree and its corresponding lefttoright postorder tree representation are given in Figure 6. In any implementation, the stored dictionary would contain the parenthesized representations of all the trees. The invention also considers other straightforward data structure representations of trees. In particular, the invention also considers the trivial extension where the righttoleft postorder ordering of the nodes of the tree is used instead of its lefttoright postorder ordering. The Solution to NsuTRecognition The methodology involves sequentially comparing Y with every element X of H, the basis of comparison being the constrained edit distance between two trees as defined by Oommen and Lee (Information Sciences, Vol. 77, pp. 253273 (1994)). In general, the actual constraint used in evaluating the constrained distance can be any arbitrary edit constraint involving the number and type of edit operations to be performed. However, in this scenario a specific constraint which implicitly captures the properties of the corrupting mechanism ("channel") which noisily garbles U into Y is used. The algorithm which incorporates this constraint has been used to test the pattern recognition system yielding a remarkable accuracy. Experimental results for the NsuT recognition problem which involve manually constructed trees of sizes between 25 and 35 nodes and which contain an average of 21.8 errors per tree demonstrate that the scheme has about 92.8% accuracy. Similar experiments for randomly generated trees yielded an accuracy of 86.4%. The solution to the Noisy Subsequence Tree Recognition Problem is described below. Notations and Definitions Let N be an alphabet and N* be the set of trees whose nodes are elements of N. Let \i be the null tree, which is distinct from X, the null label not in N. A tree T e N*. with M nodes, is said to be of size T=M. The tree will be represented in terms of the lefttoright postorder numbering of its nodes. The advantages of this ordering are catalogued by Zhang and Shasha, (SIAMJ. Comput. (1989)). The invention also considers the trivial extension where the righttoleft postorder numbering of the nodes of the tree is used instead of the lefttoright postorder numbering of the nodes. Let T[i] be the ith node in the tree according to the lefttoright postorder numbering, and let 8(i) represent the postorder number of the leftmost leaf descendant of the subtree rooted at T[i]. Note that when T[i] is a leaf, 8(0 = i. T[i..j] represents the postorder forest induced by nodes T[i] to T[j] inclusive, of tree T. T[8(i)..i] will be referred to as Tree(i). Size(0 is the number of nodes in Tree(i). The father of i is denoted as f(i). If f°(0 = i, the node fk(i) can be recursively defined as fk(i) = f(fkl(i)). The set of ancestors of i is : Anc(i) = {fk(0 0 The operation of insertion of node x into tree T states that node x will be inserted as a son of some node u of T. It may either be inserted with no sons or take as sons any subsequence of the sons of u. If u has sons u1,u2,..,uk, then for some 0 The operation of deletion of node y from a tree T states that if node y has sons yi,y2—»yk and node u, the father of y, has sons u1,u2,.uj with uj=y, then node u in the resulting tree obtained by the deletion will have sons u1,u2,...,u1l,y1,y2>...,yk,ui+l.....uj. This edit operation is shown in Figure 3. The operation of substituting node x by node y in T states that node y in the resulting tree will have the same father and sons as node x in the original tree. This edit operation is shown in Figure 4. Let d(x,y) > 0 be the cost of transforming node x to node y. If x *X*y, d(x,y) will represent the cost of substitution of node x by node y. Similarly, x * X, y = X and x = X,, y # X will represent the cost of deletion and insertion of node x and y respectively. The distances d(.,.) obey: (1) d(x,y)>0;d(x,x) = 0; d(x,y) = d(y,x); and d(x,z) sequence of trees Ao.....Afc such that A = Ao, B = Ak, and Aji > Aj via s[ for 1 The internode edit distance d(.jt) is extended to the sequence S by assigning: With the introduction of W(S), the distance between Ti and T2 can be defined as follows : D(Ti,T2) = Min {W(S)  S is an Sderivation transforming Ti to T2}. It is easy to observe that: The operation of mapping between trees is a description of how a sequence of edit operations transforms Ti into T2. A pictorial representation of a mapping is given in/. Figure 5. Informally, in a mapping the following holds : (i) Lines connecting Ti [i] and T2IJ] correspond to substituting Ti[i] by T2IJ]. (ii) Nodes in Ti not touched by any line are to be deleted. (iii) Nodes in T2 not touched by any line are to be inserted. Formally, a mapping is a triple (M,Ti,T2), where M is any set of pairs of integers (i,j> satisfying: (i) l (ii) For any pair of (ilji) and (i2»J2) in M, (a) ii = i2 if and only if j 1 = J2 (onetoone). (b) Tilii] is to the left of T1&2] if and only if T2U1] is to the left of T2D2] (the Sibling Property). (c) Titii] is an ancestor of Ti[i2l if and only if T2U1] is an ancestor of T2U2] (the Ancestor Property). Whenever there is no ambiguity, M will be used to represent the triple (M,Ti,T2), the mapping from Ti to T2. Let I, J be sets of nodes in Ti and T2, respectively, not touched by any lines in M. Then the cost of M can be defined as follows : Since mappings can be composed to yield new mappings (see Tai if. ACM, Vol 26, pp 422^33 (1979)), and Zhang and Shasha i$IAM J. Comput. Vol. 18, No. 6: pp. 12451262 (1989))), the relationship between a mapping and a sequence of edit operations can now be specified. Lemma I. Given S, an Sderivation si.....sk of edit operations from Ti to T2, there exists a mapping M from Ti to T2 such that cost (M) a sequence of editing operations such that W(S) = cost (M). Proof: Same as the proof of Lemma 2 by Zhang and Shasha QHAMJ. Comput. Vol. 18, pp. 12451262 (1989)). ••• Due to the above lemma, it can be seen that: D(Ti,T2) = Min (cost(M)  M is a mapping from Ti to T2}. ••• Thus, to search for the minimal cost edit sequence, a search has only to be performed for the optimal mapping. The Process of Constrained Tree Editing Applied to Recognizing Subsequence Trees Each of the processes involved in the recognition of NsuTs is described below using both figures and algorithmic notation. • Process RecognizeSubsequenceTree The solution to the NsuT Recognition problem is achieved by the Process RecognizeSubsequenceTrees shown in Figure 8. Figure 8 commences in 100 with the input being presented. The input, first of all, consists of the Dictionary, H. It also includes L, the expected number of feasible substitutions caused in the garbling process for the particular problem domain. It finally includes the noisy subsequence tree, Y, which is used to determine its parent whence its ungarbled version was obtained. A decision is first made in block 110 determining if there are any more trees in H. If the answer to this query is "no", the estimate X+of X* is printed in block 180. If there are more trees in H, control is given to block 120, where an assignment to X is made of the next tree in H. Another decision is now invoked in block 130 to determine if L is a feasible value. If it is not, then the closest feasible integer to L is assigned into Lp. This occurs in block 150. If the decision from 130 is "yes", then Lp is assigned the value L at block 140. Another assignment is made in block 160 to t, which is assigned to be a small set of integers around Lp. In the absence of any other information, the best estimate of the number of substitutions that could have taken place is indeed its expected value, L, which is usually close to the size of the NSuT, Y. In the examples shown in this submission, this is set to be Y  1, since the probability of a node value being substituted is usually very close to unity. One could therefore use the set {L} as the constraint set to effectively compare Y with any X e H. Since the latter set can be quite restrictive, a constraint set which is a superset of {L} marginally larger than {L} is suggested. The superset used in the examples presented in this submission is the set {Lp1, Lp, Lp+1}. At this juncture the process computes Dt(X, Y) by invoking Process Constreuned_Tree_Distance in block 170, and then control is returned to 110, where the process is repeated again until there are no more trees in H. The Process RecognizeSubsequenceTrees described above is formally described algorithmically below. PROCESS RecognizeSubsequenceTrees Input: 1. The finite dictionary H. 2. Y, a noisy version of a subsequence tree of an unknown X* in H. 3. L, the expected number of substitutions that took place in the transmission. In the examples shown in this submission, this is set to be Y  1, since the probability of a node value being substituted is usually very close to unity. Output: The estimate X+ of X*. If L is not a feasible value Lp is the closest feasible integer. BEGIN For every tree X e H do Begin If L is a feasible value then Lp = L Else Lp = closest feasible integer to L Endlf t = Superset of {L} marginally larger than {L} Compute DT(X,Y) using Algorithm Constrained_Tree_Distance End X+ is the tree minimizing Dx(X,Y) END Process RecognizeSubsequenceTrees • Process Constrained_Tree_Distance The Process RecognizeSubsequenceTrees invokes the Process Constrained_Tree_Distance shown in Figure 9. Figure 9 starts off in block 200 by reading in the array Const_T_Tw[.....] computed using the Process T_Weights which is assumed to have been invoked. It then, in block 210, passes control to an assignment statement setting DX(T,, T2) to be infinite. A decision is then made in block 220 of whether there are any more elements left in t. If there is none, control is passed to an Input/Output block at block 250, where the constrained distance Dt(T,, T2) is stored. If the decision from block 220 is "yes", control passes to an assignment statement in block 230, assigning s to take on the value of the next element in x. Subsequently, in block 240 the minimum of the current value of Dt(T,, T2) and Const_T_Wt [Ti][T2][s] is recorded in DT(T,, T^, and the control then returns to the decision block 220. This describes a loop which terminates when there are no more elements in t. The Process Constrained'_Tree_Distance described above is formally described algorithmically below. PROCESS Constrained_Tree_Distance Input: The array Const_T_Wt [.,.,.] computed after first invoking Process T_Weights. Output: The constrained distance Dx(Ti,T2) with t = Superset of {L} marginally larger than {L} BEGIN Invoke Process T_Weights and store the results in array Const_T_Wt [.,.,.] DT(Tl,T2) = oo; For all s in t Do DT(Ti,T2) = Min {DT(Ti,T2), ConstJMVt [Ti][T2][s]} EndFor END Process Constrained_Tree_Distance • Process T_Weights The Process ConstrainedTreeDistance first invokes the Process T_Weights shown in Figure 10. Figure 10 begins with an Input/Output block (block 300) where the Trees T, and T2 and the set of elementary edit distances are read into the system. It then invokes the Process Preprocess (T^ T2) to get 5Q and Essential_Nodes of both trees in block 310. This is followed by an assignment of the variable i' to unity in block 320. A decision block is then invoked in 330 to determine of i' is less than or equal to Essential_Nodes,Q   this constitutes the start of a looping structure. If it is not, an Input/Output operation is performed in block 385, where the values of Const_T_Wt(i, j, s) are stored for i between 1 and T,, j between 1 and T2, and s is between 1 and the minimum of T, and T2. If the decision from block 330 is "yes", an assignment of j' to unity occurs in 340, followed by another decision block (forming an inner loop) in 350 to see if j9 is less than or equal to  Essential_Nodes2[ ] . If the output of this decision block is "no", then i' is incremented in 380, and control is returned to block 330, which constitutes the outer loop. If the decision from block 350 is "yes", an assignment block (360) occurs where i is set to the next value in Essential_ Nodes,, which is Essential_ Nodes,[ i']f and j is set to the next value in Essential_ Nodes2, which is Essential_ Nodes2[ j']. This is followed by invoking the Process Compute_Const_Wt for values of i and j in 370. This leads to the final statement in the loop, at block 375, where j' is incremented, and control is returned to block 350, the. top of the inner loop. The Process T_Weights described above is formally described algorithmically below. PROCESS T_Weights Input: Trees Ti and T2 and the set of elementary edit distances. Output: Const_T_Wt[i, j, s], 1 £ i Assumption: The Process Preprocess has been invoked with trees Ti andT2 to yield the 8Q and Essential_Nodes D arrays for both trees. These quantities are assumed to be global. BEGIN Preprocess (Ti,T2) ; For i' = 1 to  EssentiaI_NodesiG Do For j1 = 1 to  Essential_Nodes2D Do i = Essential_Nodesi [i'3; j = Essential_Nodes2 I}']', Compute_Const_T_Wt(i, j); EndFor EndFor END Process T_Weights. • Process Preprocess The Process T_Weights first invokes the Process Preprocess shown in Figure 11. Figure 11 starts off with a sequence of Input/Output operations in block 400 where both the trees T, and T2 are read in. Subsequently, in block 410 the 8Q and Essential_NodesQ for both trees are calculated. Finally, these two variables are stored back into the system in block 420, before returning in 430. The Process Preprocess is so straightforward and so its formal algorithmic description is omitted. This leads us to the Process which does most of the computing, the Process Compute_Const_T_Wt shown in a sequence of figures starting from Figure 12. • Process Compute_Const_T_Wt Figure 12 commences in block 500 with an Input/Output operation where the indices i and j and the quantities assumed global in the Process T_Weights are read in. A series of assignments in block 510 then occurs with the following assignments which are essentially initializations of the local variables : N = i5,(i) + l M = j82(j) + l R = Min{M,N} b, = 8,(01 b2 = 620)l : Const_F_Wt[0][0][0] = 0, and Xj = 1. A decision in block 520 is invoked to determine if x, is less than or equal to N  this is the beginning of a loop. If it is not, control is passed to block 560, where y, is initialized to be 1. Control is then passed to block 590, which leads to the next phase of this method. If the decision in block 520 is "yes", the assignments : Const_F_Wt [x,][0][0] = Const_F_Wt [x, 1][0][0] + d(T,[x, + b,] > X), and Const_T_Wt [x, + b,][0][0] = Const_F_Wt [x,][0][0] occur in blocks 530, and 540 respectively. This is followed by incrementing x, in block 550. The Process continues in Figure 13. Figure 13 continues where Figure 12 left off, starting with a decision in block 600, where a test is invoked to see if y, is less than or equal to M. This initiates another loop. If it is not, control is passed on to block 640 explained, presently. If however, the test in block 600 returns a "yes", the assignments : Const_F_Wt [0][y,][0] = ConstJMVt [0][ y, l][0] + dCWTjy, + bj), and Const_T_Wt [0][y, + b2][0] = Const_F_Wt [0][y,][0] in blocks 610 and 620 respectively are done. The final block in the loop, labeled 630, increments y, before it passes control back to block 600. Continuing from the response of "no" from block 600, the process carries out an assignment of s to 1 in block 640. This is followed by the decision to test if s is less than or equal to R in block 650  which constitutes the entry of another loop. If the answer to block 650 is "no", control is passed to block 690, which is the next phase of this process. If. however, the answer to block 650 is "yes", the following assignments occur in blocks 660 and 670 respectively: Const_F_Wt [0][0][s] = «, and Const_T_Wt [0][0][s] = Const_F_Wt [0][0][s]. Finally, s is incremented in block 680 before control is returned to block 650 for the next iteration of the loop. The process continues in Figure 14. Figure 14 further develops the Process (Compute_Const_T_Wt) with an assignment of x, to 1 in block 700. Thereafter the Process makes a decision in block 710 to test if x, is less than or equal to N — which initializes a loop. If the decision in block 710 is "no", control is passed to block 780 (which is an assignment of x, to 1) which then passes control to the next phase of the method, block 790. If, on the other hand, the decision to block 710 is "yes", the assignment yt = 1 occurs in block 720, and another loop whose starting decision block is at block 730 is encountered. This block tests the query "is y, less than or equal to M?". If the answer to this query is "no", control is passed to 770, which increments x,, before finishing this iteration of the inner loop and passing control back to 710. If the answer to this query is "yes", the following assignments are computed in block 740 and 750 respectively: Const_F_Wt [x,][y,][0] = the minimum of (a) Const_F_Wt [x,][y, 1][0] + d(X »¦ T2 [y, + bj), and (b) Const_F_Wt [x, l][y,][0] + d(T,[x, + b,] » X), and (c) Const_T_Wt [x, + b,] [ yl + b2] [0] = ConstJMVt [x,] [yj [0]. The outer loop concludes each iteration by incrementing y, in block 760 before control being passed back to block 730. Figure 14 continues to the subsequent operations of the Process in Figure 15. Figure 15 continues the Process with the test "is x, less than or equal to N ?" in block 800. Again, this is the beginning of a loop. If the test in block 800 returns a negative answer, control is passed to block 880 where y, is set to 1 before going on to the next phase in block 890. If the test in block 800 returns a positive answer, the Process does an assignment of x, = 1 in block 810, followed by another assignment of s = 1 in block 820. At this juncture the Process initiates another looping decision block at block 830, which queries if s is less than or equal to R. If the answer to the query in block 830 is "no", control is passed to block 870, where x, is increased by one and the control flows back to block 800. If the answer to the query in block 830 is "yes", control is passed to blocks 840 and 850 with the following assignments : Const_F_Wt [x,][0][s] = oo, and ConstJMYt [Xi + b,][0][s] = Const_F_Wt [x,][0][s]. This is followed by incrementing s before control is passed back to block 830. The Process continues in Figure 16. Figure 16 continues the process where Figure 15 left off. The first block is a loopinitializing decision in block 900 evaluating the question "is y, less than or equal to M ?". If the answer to the query in block 900 is in the negative, control is passed to block 970 with the assignment x, = 1 before proceeding to the next figure {Figure 17) in block 990. If the answer to the query in block 900 is in the positive, block numbered 910 is encountered where s is initialized to 1. The process then embarks on another loopinitializing decision in block 920 where the question "is s less than or equal to R" is processed. If the answer to the query in block 920 is "no", control is passed to block 960 where y, is incremented before control is passed back to block 900. If the answer from block 920 is "yes", the following assignment statements are done in blocks 930 and 940 respectively : Const_F_Wt [0][y,][s] = », and Const_T_Wt [0][y, + b2][s] = Const_F_Wt[0][y,][s]. Before returning to block 920, s is incremented in block 950. The Process continues in Figures 17 and 18. Figures 17 and 18 describe parallel sections of the same process, and so they are described together. The process first executes block 1000, which evaluates the question "is x, less than or equal to N?'\ This block initates a loop. If the answer to this query is "no", the Process traverses link 13, and proceeds to block 1140, which is the Input/Output block which stores the value of Const_T_Wt [i,, j,, s] for i, being between 8,(i) and i, j, being between 82(j) and j, and finally s being between 0 and the minimum of [Size(i), Size(j) 3. At block 1140, the control passes to the final return block of the method, which is block 1150. If, however, the response from block 1000 is "yes", y, is initialized to be 1 in block 1010 before entering another loop. The question in the decision block 1020 tests if y, is less than or equal to M. If the answer to block 1020 is negative, the Process traverses link 11 and proceeds to block 1130 of Figure 18, which increments y, before backtracking Iinkl2 to block 1000. If the answer to blockl020's question was in the affirmative, the Process proceeds to block 1030, where s is set to 1 and where the Process resolves another decision at block 1040. The question asked at block 1040 is : "Is s less than or equal to R?'\ If the answer to this query is "no", the Process jumps to Figure 18 through link 9 which brings it to block 1120 where y, is increased by 1. At this juncture control is passed back up through link 10 to Figure 17, to block 1020 for the next iteration of this loop. If the decision from block 1040 turns out to be "yes", the Process immediately encounter another decision block. However, this one does not initiate a loop. At this block, numbered 1050, it is determined whether 8,(x, + b,) = 8,(x) and 52(y, + bj = 82(y). If the computation of block 1050 yields a "no", the Process traverses link 7 to Figure 18. This leads the Process to block 1100, which assigns: Control to block 1110, which increments s, backtracks to Figure 17 through link 8, to block 1040. If the decision from block 1050 yields a "yes", however, the Process proceeds to block 1060 where it computes the following assignment: This in turn, leads the Process to block 1070, where Const_T_Wt [x, + b,] [y, + bj[s] is assigned to take the value of Const_F_Wt [x,][ y,][s]. Control then passes to block 1110, described earlier, through link 6. This completes the description of this figure, and the entire Process. The Process Compute_Const_T_Wt described above in detail, is formally described algorithmically below. PROCESS Compute_Const_T_Wt Input: Indices i, j and the quantities assumed global in T_Weights. Output: Const_T_Wt [ii, ji, s], 5i(i) M = j  82O) +1; /* size of subtree rooted at T2[j] */ R = Min{M,N}; bi = 81 (i) 1; /* adjustment for nodes in subtree rooted at Ti [i] */ X>2  82(j) 1'» I* adjustment for nodes in subtree rooted at T2IJ] */ Const_F_Wt [0] [0] [0] = 0; /* Initialize Const_F_Wt */ For xi = 1 to N Do Const_F_Wt [xi][0][0] = ConstJF_Wt [xil][0][0] + d(Ti[xi+bi ]?*,); Const_T_Wt [xi+bi][0][0] = Const_F_Wt [xi][0][0]; EndFor For yi = 1 to M Do Const_F_Wt [0][yi][0] = Const_F_Wt [0][yil][0] + d(>.»T2[yi+b2]); Const_T_Wt [0][yi+b2l[0] = Const_F_Wt [0][yi][0]; EndFor For s = 1 to R Do Const_F_Wt [0][0][s] = 00; Const_T_Wt [0][0][s] = Const_F_Wt [0][0][s]; EndFor Const_T_Wt [xi+bi][O][s] = Const_F_Wt [xi][O][s]; EndFor EndFor For yi = 1 to M Do For s = 1 to R Do Const_F_Wt[0][yi][s]=co; Const_T_Wt [0][yi+b2][s] = Const_F_Wt [0][yi][s]; EndFor EndFor For xi = 1 to N Do For yi = 1 to M Do For s = 1 to R Do If 6i(xi+bi) = 8i(x) and 82(yi+b2) =52(y) Then Const_F_Wt klHyiMs] = Min 'Const_F_Wt [xil][y i] [s] + d(Ti [xi+bil)A) Const_F_Wt [xi][yil][s] + d(X>T2[yi+b2l) ' Const_F_Wt [xil][yil][sl] + d(Ti[xi+bi]»T2tyi+b2l) Const_T_Wt [xi+bi][yl+b2][s] = Const_F_Wt [xi][yi][s]; Else Endlf EndFor EndFor EndFor END Process Compute_Const_T_Wt The Process RecognizeSubsequenceTrees assumes that the constrained distance subject to a specified constraint set, t, can be computed. Since t is fully defined in terms of the Const_T_Wt [xi+biJ[O][s] = ConstJFJWt [xi][O][s]; EndFor EndFor For yi = 1 to M Do For s = 1 to R Do Const_F_Wt[0][yi][s]=«>; Const_T_Wt [0][yi+b2][s] = Const_F_Wt [0][yi][s]; EndFor EndFor For xi = 1 to N Do For yi = 1 to M Do For s = 1 to R Do If 8i(xi+bi) = 5i(x) and 62(yi+b2> =52(y) Then Const_F_Wt [xi][yi][s] = Min 'Const_F_Wt fxil][yi][s] + d(Ti[xi+bi3>>X) Const_F_Wt [xi][yil][s] + da^T2[yi+b2l) ] Const_F_Wt [xil][yil][sl] + d(Ti[xi+bi]»T2[yi+b2l) Const_T_Wt [xi+bi][yi+b2lts] = Const_F_Wt [xi][yi][s); Else Const_F_Wt [x1][y1][s] Endlf EndFor EndFor EndFor END Process Compute_Const__T_Wt The Process RecognizeSubsequenceTrees assumes that the constrained distance subject to a specified constraint set, t, can be computed. Since x is fully defined in terms of the Consider the problem of editing T1 to T2, where Ti = N and [T2] = M. Editing a postorderforest of T1 into a postorderforest of T2using exactly i insertions, e deletions, and s substitutions, corresponds to editing T1[l..e+s] into T2[l..i+s]. Bounds on the magnitudes of variables i, e, s, are obtained by observing that they are constrained by the sizes of trees T1 and T2. Thus, if r=e+s, q=i+s, and R=Min{N,M}, these variables will have to obey the following constraints : Values of (i,e,s) which satisfy these constraints are termed feasible values of the variables. Let Hi, He, and H$ are called the set of permissible values of i, e, and s. Theorem I specifies the feasible triples for editing Ti[l..r] to T2[l..q]« Theorem I. To edit Ti[l..r], the postorderforest of Ti of size r, to T2[l..q], the postorderforest of T2 of size q, the set of feasible triples is given by {(qs, rs, s) 10 Consider the constraints imposed on feasible values of i, e, and s. Since the problem involves editing Ti[l..r] to T2[l»ql, only those triples (i,e,s) in which i+s=r and e+s=q have to be considered. But, the number of substitutions can take any value from 0 to Min{r,q}. Therefore, for every value of s in this range, the feasible triple (i,e,s) must have exactly rs deletions since r=e+s. Similarly, the triple (i,e,s) must have exactly qs insertions since q=s+i. The result follows. ••• An edit constraint is specified in terms of the number and type of edit operations that are required in the process of transforming T1 to T2 It is expressed by formulating the number and type of edit operations in terms of three sets Qi, Qe, and Qs which are subsets of the sets Hi, He, and Hs defined above. Thus, to edit T1 to T2 performing no more than k deletions, the sets Qs and Qj are both , the null set, and Qe = {j  j e He, j n He, and Qs = {ks} n Hs. Theorem II. Every edit constraint specified for the process of editing T1 to T2 is a unique subset of Hs. Proof: Let the constraint be specified by the sets Qi, Qe, and Qs. Every element j e Qi requires editing to be performed using exactly j insertions. Since T2 = M, from Theorem 1, this requires that the number of substitutions be Mj. Similarly, if j € Qe, the edit transformation must contain exactly j deletions. Since Ti = N, Theorem 1 requires that Nj substitutions be performed. Let Qe*=(Njj eQeLand Qi*=(Mjj eQi}. Thus, for any constraint, the number of substitutions permitted is Qs r> Qe* r» Qi* c Hs. ••• To clarify matters, consider the trees T1 and T2 shown in Figure 5. If T1 has to be transformed to T2 by performing at most 5 insertions, at least 3 substitutions and the number of deletions being 3, then Qi = {0,1,2,3,4,5}, Qe={3}, and Qs = {3,4,5,6}. From these it can be seen that: Qe* = {5}, and Qi* = {1,2,3,4,5,6} yielding, t = Qs n Qe* n Qi* = {5}. Hence, the optimal transformation must contains exactly 5 substitutions. The edit distance subject to the constraint t is written as DT(T1,T2). By definition, Dx(Tl,T2) = 00 if t = , the null set. The computation of DT(T1,T2) is now considered. Constrained Tree Editing Since edit constraints can be written as unique subsets of Hs, the distance between forest T1[i'..i] and forest T2Jj'..j] subject to the constraint that exactly s substitutions are performed, is denoted by Const_F_Wt{T1[i'..i],T2D'J].s) or more precisely by Const_F_Wt([i'..i],j<..j the distance between t1fl.i and t2u..j subject to this constraint is given by const_f_wt since starting index of both trees unity. as opposed subtree rooted at i j same const_t_wt difference subtle. indeed> Const_T_Wt(i,j,s) = Const_F_Wt(T1[8(i)..i],T2[80)..j],s). These weights obey the following properties proved in Oommen and Lee {Information Sciences, Vol. 77, pp. 253273 (1994)). Lemma II Let ii € Anc(i) and ji e Anc(j). Then (i) Const_F_Wt(u^O)=0. (ii) Const_F_Wt(T1[5(il)..i],u,0) = Const_F_Wt(Tl[8(il)..il],u,0) + d(T1[iU). (iii) Const_F_Wt(^T2[5(ji)..j],0) = Const_F_Wt(u,T2[8(jl).jl],0) + da,T2[j]). (iv) Const_F_Wt(T1[8(ii)..i],T2[8(ji)..j],0) = Min f Const_F_Wt(T1[6(il)..il],T2[8(Jl)"J]>0) + d(T1[i],X) ( Const_F_Wt(T1[8(ii)..i],T2[8(jl)..jl],0) +da,T2lj]). (v) Const_F_Wt(T1 [8(ii)..i],u,s) =00 if s > 0. (vi) Const_F_Wt(n,T2[8(jl).J],s)=oo ifs>0. (vii) Const_F_Wt(n,u.,s) =00 if s > 0. Proof: The proofs are found as the proofs of Lemmas Ha and lib of Oommen and Lee (Information Sciences, Vol. 77, pp. 253273 (1994)). ••• Lemma II essentially states the properties of the constrained distance when either s is zero or when either of the trees is null. These are "basis" cases that can be used in any recursive computation. For the nonbasis cases, the scenarios when the trees are nonempty and when the constraining parameter, s, is strictly positive are considered. Theorem in gives the recursive property of Const_F_Wt in such a case. Theorem III. Let ii e Anc(i) and ji e Anc(j). Then Const_F_Wt(T1[5(ii)..i],T2[8(Jl)..j],s) = Min 'Const_F_Wt([5(ii)..il],[5(Ji)..j],s) + d(T1[i],X) Const_F_Wt([8Gi)..i],[80i)..jl],s) + d(X,T2\}]) Min l 273 (1994)). A minimum cost mapping M between T1[8(ii)..i] and T2[8(jl)..j] using ? exactly s substitutions has to be determined. The map can be extended to T1[i] and T2IJ] in the following three ways : (i) If T1 [i] is not touched by any line in M, then T1 [i] is to be deleted. Thus, since the number of substitutions in Const_F_Wt(.,.,.) remains unchanged, the following is true: Const_F_Wt(T1[8(ii)..i],T2[8(ji)..j],s) = Const_F_Wt(T1[8(ii)..il],T2[8Ql)..jLs) + d(T1[iU). (ii) If T2IJ] is not touched by any line in M, then T2IJ] is to be inserted. Again, since the number of substitutions in Const_F_Wt(.,.,.) remains unchanged, the following is true: Const_F_Wt(T1[8Ui)..i],T2[8(ji)..j],s) = Const_F_Wt(T1[8Gl)..i],T2[8(ji)..jl],s) + da,T2Ul). (iii) Consider the case when both T1[i] and T2IJ] are touched by lines in M Let (i,k) and (h j) be the respective lines, i.e. (i,k) and (h,j) e M. If 8(ii) rightmost sibling in T2[S(ji)..j]. Similarly, if i is a proper ancestor of h, then k must be a proper ancestor of j by virtue of the ancestor property of M. This is again impossible since k By the ancestor property of M (see Oommen and Lee (Information Sciences, Vol. 77, pp. 253273 (1994)) for the details of this argument), any node in the subtree rooted at T1[i] can only be touched by a node in the subtree rooted at T2[fl« Since exactly s substitutions must be performed in this transformation, the total number of substitutions used in the subtransformation from T1[5(ii)..8(i)1] to T2[8(ji)..8(j)1] and the subtransformation from T1[8(i)..i1] to T2[8(j).jl] must be equal to s1 (the last substitution being the operation Tl[i] ¥ T2IJ]). If S21 is the number of substitutions used in the subtransformation from Ti[8(i)..i1] to T2[8(j)..j1], s2 can take any value between 1 to Min{Size(i),Size(j),s}. Hence,. Const_F_Wt(Tit8(ii)..i],T2[8(Ji)..j],s) rConst_F_Wt(Ti[8(ii)..8a)l],T2[8(Jl)"80)l],ss2) Min = l Since these three cases exhaust the possible ways for yielding Const_F_Wt(8(ii)..i,8(ji)..j,s), the minimum of these three costs yields the result. Theorem III naturally leads to a recursive method, except that its time and space complexities will be prohibitively large. The main drawback with using Theorem III is that when substitutions are involved, the quantity Const_F_Wt(Ti[8(ii)..i],T2[8(ji)..j],s) between the forests Ti[8(ii)..i] and T2[8(jl)..j] is computed using the Const_F_Wts of the forests Ti[8(ii)..8(i)1] and T2[8(ji)..8(j)1] and the Const_F_Wts of the remaining forests Ti[8(i)..i1] and T2[8(j)..j1]. Since under certain conditions, the removal of a subforest leaves us with an entire tree, the computation is simplified. Thus, if 8(i)=8(ii) and 8(j)=8(jl) Ge., i and ii, and j and ji span the same subtree), the subforests from Ti[8(ii)..8(i)l] and T2[8(jl)..S(j)l] do not get included in the computation. If this is not the case, the Const_F_Wt(Ti[8(ii)..i],T2[8(jl).j],s) can be considered as a combination of the Const_F_Wt(Ti[8(ii)..8(i)l], T2[8Gl)..5Q)l],ss2)) and the tree weight between the trees rooted at i and j respectively, which is Const_T_Wt(i,j,s2). This is proved below. otherwise, Const_F_Wt(Ti[8(ii)..i],T2[8(jl)J].s) Min Sketch of Proof: By Theorem m, if 8(i) = 8(ii) and 8(j) = 8(jl), the forests Ti[8(ii)..8(i)1] and T2[8(jl)"8(j)1] are both empty. Thus, Const_F_Wt(Tl[8(il)..8(i)l], T2[8(jl)..8(j)l],ss2) = Const_F_Wt(u,n,ss2) which is equal to zero if s2  s, or is equal to oo if S2 follows. For the second part, using arguments given in Oommen and Lee (Information Sciences, Analogously, it can be shown that: Const_T_Wt(i,j,s2) Theorem III and these two inequalities justify replacing Const_T_Wt(ij,s2) for the corresponding Const_F_Wt expressions, and the result follows. The details of the proof are found in Oommen and Lee (Information Sciences, Vol. 77, pp. 253273 (1994)). ••• Theorem IV suggests that a dynamic programming flavored method can be used to solve the constrained tree editing problem. The second part of Theorem IV suggests that to compute Const_T_Wt(ii,ji,s), the quantities Const_T_Wt(ij,s2) must be available for all i and j and for all feasible values of 0 which are on the path from ii to 5(il) get computed as a byproduct in the process of computing the Const_F_Wt between the trees rooted at ii and jl. These distances are obtained as a byproduct because, if the forests are trees, Const_F_Wt is retained as a Const_T_Wt. The set of nodes for which the computation of Const_T_Wt must be done independently before the Const_T_Wt associated with their ancestors can be computed is called the set of Essential_Nodes, and these are merely those nodes for which the computation would involve the second case of Theorem IV as opposed to the first The set Essential_Nodes of tree T is defined as: Essential_Nodes(T) = {k  there exists no k' > k such that 8(k) = 8(k')}. Observe that if k is in Essential_Nodes(T) then either k is the root or k has a left sibling. Intuitively, this set will be the roots of all subtrees of tree T that need separate computations. Thus, the Const_T_Wt can be computed for the entire tree if Const_T_Wt of the Essential_Nodes are computed. Based on these arguments Const_T_Wt(i, j, s) can be computed and stored it in a permanent threedimensional array Const_T_WL From Theorem IV, it can be observed that to compute the quantity Const_T_Wt(i, j, s) the quantities which are involved are precisely the terms Const_F_Wt([8(i)..h], [5(j)..k], s') defined for a particular input pair (i, j), where h and k are the internal nodes of Treel(i) and Tree2(j) satisfying, 8(0 £ h £ i, 8(j) as b1 = 8i(i)  1, and b2 = 82O)  1. Thus, for a particular input pair (ij), the same memory allocations Const_F_Wt [.....] can be used to store the values in each phase of the computation by assigning for all l The space required by the above Process is obviously O(Ti * T2 * Min{Ti, T2}). If Span(T) is the Min{Depth(T), Leaves(T)}, the Process' time complexity is (see Oommen and Lee information Sciences, Vol. 77, pp. 253273 (1994))): O(Ti * T2 * (Min{Ti, T2})2 * Span(Ti) * Span(T2)). Rationale for the Principles Used in Noisy SubsequenceTree Recognition Using the foundational concepts of constrained edit distances explained in the previous sections, the principles used in Noisy SubsequenceTree recognition are now justified. The assumptions made in the recognition process are quite straightforward First of all, it is assumed that a "Transmitter" intends to transmit a tree X* which is an element of a finite dictionary of trees, H. However, rather than transmitting the original tree the transmitter opts to randomly delete nodes from X* and transmit one of its subsequence trees, U. The transmission of U is across a noisy channel which is capable of introducing substitution, deletion and insertion errors at the nodes. Note that, to render the problem meaningful (and distinct from the unidimensional one studied in the literature) it is assumed that the tree itself is transmitted as a two dimensional entity. In other words, the serialization of this transmission process is not considered, for that would merely involve transmitting a string representation, which would, typically, be a traversal predefined by both the Transmitter and the Receiver. The receiver receives Y, a noisy version of U. The rationale for recognizing X* from Y is discussed below. To render the problem tractable, the solution assumes that some of the properties of the channel can be observed. More specifically, the solution assumes that L, the expected number of substitutions introduced in the process of transmitting U, can be estimated. In the simplest scenario (where the transmitted nodes are either deleted or substituted for) this quantity is obtained as the expected value for a mixture of Bernoulli trials, where each trial records the success of a node value being transmitted as an nonnull symbol. Since U can be an arbitrary subsequence tree of X*, it is obviously meaningless to compare Y with every X e H using any known unconstrained tree editing algorithm. Before Y can be compared to the individual tree in H, the additional information obtainable from the noisy channel will have to be used. Also, since the specific number of substitutions (or insertions/deletions) introduced in any specific transmission is unknown, it is reasonable to compare any X e H and Y subject to the constraint that the number of substitutions that actually took place is its best estimate. Of course, in the absence of any other information, the best estimate of the number of substitutions that could have taken place is indeed its expected value, L. This is usually close to the size of Y since the probability of a node value being substituted is very close to unity. In the examples explained below, this is set to be Y  1. One could therefore use the set {L} as the constraint set to effectively compare Y with any X e H. Since the latter set can be quite restrictive, a constraint set which is a superset of {L} marginally larger than {L} is suggested. The superset used in the examples presented in this submission is the set {Lp1, Lp, Lp+1}. Since the size of the set is still a constant, there is no significant increase in the computation times. This is exactly the rationale for the recognition Process RecognizeSubsequenceTrees described earlier. Recognition ofRNA Structures One embodiment of this invention is the use of the method for the processing of ribonucleic acid (RNA) secondary structures from their tree representations (see Le et al (Comp. Appl. Biosci. (1989)); Le et al (Computers andBiomedical Research, 22, 461473 (1989)); Shapiro and Zhang {Comp. Appl. Biosci. (1990)); Shapiro (Comput. Appl. Biosci., 387393 (1988)); Takahashi etal {Analytical Science, Vol. 3, 2328 (1987)). A molecule of RNA is made up of a long sequence of subunits (the Ribonucleotides (RN)) which are linked together. Each Ribonucleotide contains one of the four possible bases, abbreviated by A, C, G, and U. This base sequence is called the primary structure of the RNA molecule. One example of an item that can be represented by a tree structure is the secondary structure of Ribonucleic Acids (RNA). Under natural conditions, a RNA sequence twists and bends and the bases form bonds with one another to yield complicated patterns. The latter bonding pattern is called its secondary structure. Research in this field has shown that similar structures have similar functionality and the use of sequence comparison by itself is inadequate for determining the structural homology as described by Shapiro and Zhang (Comp. Appl Biosci. (1990)). For example, a typical secondary structure of an RNA sequence may be represented as a tree, as explained by Shapiro and Zhang (Comp. Appl Biosci. (1990)) and Shapiro (Comput. Appl Biosci., 387393 (1988)) using node values such as M, H, I, B, R and N (for Multiple loop, Hairpin loop, Internal loop, Bulge loop, helical stem Region, and exterNal singlestranded region respectively). This representation only considers the topology of the loops and stem regions, so a more dissected representation would have to also consider the sizes of the loops and the helical stems Using this treerepresentation and the method of this invention, the comparison of RNA secondary structure trees can also help identify conserved structural motifs in an RNA folding process and construct taxonomy trees as explained by Shapiro and Zhang (Comp. Appl Biosci. (1990)). In all such molecular biological domains, the method proposed here can be used to recognize (classify) RNA secondary structure trees by merely processing noisy (garbled) versions of their subsequence trees. This could assist the biologist trace proteins when only their fragments are available for examination. Rather than work with the above tree representations of RNA structures described above, to demonstrate the power of the scheme, a more recent tree representation of RNA secondary structures by Zhang (Zhang Proceedings of IEEE International Joint Symposia on Intelligence and Systems, Rockville, Maryland, May 98, pp. 126132 (1999)) is now referred to. Figure 19 is & schematic diagram showing how the method described by the invention can be used in the recognition of RNA molecules from their noisy fragments. Since RNA secondary structures can be directly represented as a tree structure, the recognition of the RNA secondary structures from its fragment is a straightforward application of the solution to the NsuT problem. The intersymbol distances in this case can be specified in terms of the likelihood of one base (or base pair) being misrepresented by another. This is traditionally achieved using the negative likelihood function. In the absence of such information, traditional 0/1 distances for equal/nonequal bases or base pairs can be utilized. They can also be learnt using the training methodology explained earlier. Use in Taxonomy In the classical sense, taxonomy refers to the science of classifying organisms; the process of classification provides a framework for the organization of items. Today, however, the notion of taxonomy is extended well beyond the classification of organisms to items such as DNA gene sequences, for example. The value of classification comes from it serving as an index to stored information, having a heuristic value which allows for prediction and interpolation, which permits the making of generalizations, and serves as a basis for explanation. The three main schools or philosophical approaches to taxonomy are 1) phenetic taxonomy or numerical taxonomy, which classifies on the basis of overall morphological or genetic similarity; 2) cladistic taxonomy or phylogenetic taxonomy, which classifies strictly on branching points; and 3) evolutionary taxonomy, traditional taxonomy, or gradistic taxonomy, classifies on a combination of branching and divergence. It is important to note that within the field of taxonomy there may be two levels of tree representation. The first is the relationship between elements, as illustrated in Figure 30. The second is the representation of each element (eg. a gene sequence) in an 'element specific' or 'signature* tree structure form, as dictated by the kinds of different features and the relationship of such features which each element may or may not have and in a manner similar to Figures 19AD, 20AD and 21AD. The method of the invention uses the matching of this second type of tree structures to then identify the closest known element in a relational tree of elements and thereby obtain information regarding, for example, related gene sequences. In another embodiment, the method of this invention can be utilized in tree and string taxonomy in a straightforward manner, when tree taxonomy or string taxonomy is applicable to determining the relationship between two or more elements. The tree taxonomy problem involves determining the similarity/dissimilarity and relationship between the various trees in a set of trees. These trees can be, for example, the tree representations of various viruses/bacteria or the genetic tree representations of various biological species, or compounds. Generally, pairs of trees having shorter intertree distances are more likely to be interrelated than those with longer intertree distances, permitting a relationship between the various trees to be determined. Using the method of this invention, one may readily determine an enhanced similarity/dissimilarity measure (ie. the intertree constrained edit distance) between the various trees in a set of trees, thereby providing a measure of the relative similarity/dissimilarity between the various trees in a set of trees from which the taxonomy of the trees may be established. In a further embodiment of this invention, sets of trees having shorter intertree distances measured using the method of this invention, may be clustered according to their similarity, into subdictionaries, each subdictionary containing a cluster of similar trees. By such a clustering, a hierarchical classification can be achieved. This clustering process can be repeated recursively to further refine the hierarchical classification. Moreover, since a string can be considered as a tree in which each parent node has exactly one child, the current invention can be directly applied to the corresponding problems involving strings  including the string taxonomy problem which involves determining the mutating relationships between the elements of a set of strings, which strings can be, for example, the representations of various viruses/bacteria, or the genetic string representations of various biological species, or compounds. Taxonomy Applied to Bioinformatics and DNA Sequence Analysis In addition to classical taxonomy with respect to organisms, one area of science where the need for taxonomy is mounting exponentially is with regard to DNA sequences, paralleling the rate of gene sequencing. The advent of cloning technology allowing foreign DNA sequences to be easily introduced into a bacteria has enabled rapid, mass production of particular DNA sequences. Oligonucleotide synthesis provided researchers with the ability to construct short fragments of DNA with sequences of their own choosing which could be used to probe vast libraries of DNA to extract genes containing the same sequence as the probe. These fragments could also be used in polymerase chain reactions to amplify existing DNA sequences or to modify these sequences. In order to utilize this information however, access to a collected pool of sequence information and a method of extracting from this pool only those sequences of interest. Advances in computer technology have provided the means to store and organize sequence information into databases in addition to analyzing sequence data rapidly. Then, means for readily comparing sequences is needed in order to compare sequences to determine gene function, developing phylogenetic relationships and simulating protein models. Scientific research has shown that all genes share common elements, and for many genetic elements, it has been possible to construct consensus sequences representing the norm for a given class of organisms. Common genetic elements include promoters, enhancers, polyadenylation signal sequences and protein binding sites. Genetic elements share common sequences which enables the application of mathematical algorithms to be applied to the analysis of sequence data. Theoretical scientists have derived new and sophisticated algorithms which allow sequences to be readily compared using probability theories. Such comparisons may them become the basis for determining gene function, developing phylogenetic relationships and simulating protein models. Hence even if the source of a particular sequence is not known, identifying a different sequence which most closely resembles the first and which may in turn be linked through taxonomic classification to a corresponding elemental tree of a class of genes. There is even potential to obtain further information if for example, the translation of the gene sequences into protein sequences could then be related totan elemental tree depicting the relationship between members of a class of proteins. Recognition of Chemical Compounds Described in Terms of Molecules In another embodiment, the method of this invention can be used to recognize chemical compounds that are described in terms of molecules. They are recognized from their noisy fragments, also described in terms of their component molecules. Since chemical compounds are graphs, each compound is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the compound is also mapped into a set of representative tree structures. The compound recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each compound and the tree representations of the noisy fragment. Figure 20 is a schematic diagram showing how the invention can be used, for this purpose, and the implementation of the invention is straightforward by specifying the intersymbol distances between the molecules. These distances can be specified in terms of the likelihood of one molecule being transformed into (misrepresented by) another. This is traditionally achieved using the negative likelihood function. In the absence of such information, traditional 0/1 distances for equal/nonequal symbols can be utilized. They can also be learnt using the training methodology explained earlier. Recognition of Chemical Compounds Described in Terms of Atomic Structures In another embodiment, the method of this invention can be used to recognize chemical compounds that are described in terms of atomic structures. They are recognized from their noisy fragments, also described in terms of their component atomic structures. Since chemical compounds are graphs, each compound is first mapped into a set of representative tree structures, where the nodes are the atoms. Similarly, the noisy fragment of the compound is also mapped into a set of representative tree structures. The compound recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each compound and the tree representations of the noisy fragment Figure 20 is a schematic diagram showing how the invention can be used for this purpose, and the implementation of the invention is straightforward by specifying the intersymbol distances between the respective atoms. These distances can be specified in terms of the likelihood of one atom being transformed into (misrepresented by) another, and is related to the positions of the atoms in the periodic table. This can be achieved using the negative likelihood function of the confusion probabilities. In the absence of such information, traditional 0/1 distances for equal/nonequal symbols can be utilized. The intersymbol distances can also be learnt using the training methodology explained earlier. Fingerprint Recognition In another embodiment, the method of this invention can be used to recognize fingerprints. The fingerprints are first preprocessed as described by Johannesen et al ((Proc. of SSPR'96, (1996)) and described in terms of their minuatae. This is the straightforward necessary step required in any fingerprint recognition system, because the fingerprint image has to represented in terms of the features, and the best features in this problem domain are the minuatae. They are recognized from their noisy subportions which may or may not be contiguous. These noisy subportions are also described in terms of their component minuatae after the same preprocessing. Since numerous minuatae representations of each fingerprints are possible, each fingerprint is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the fingerprint is also mapped into a set of representative tree structures. The fingerprint recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each fingerprint and the tree representations of the noisy subportion. Figure 22 is a schematic diagram showing how the invention can be used for this purpose, and the implementation of the invention is straightforward by specifying the intersymbol distances between the respective types of minuatae. These distances can be specified in terms of the likelihood of one minuatae being transformed into (misrepresented by) another, and is related to the characteristics of the image processing environment which distinguishes the minuatae themselves from the "raw" image. In the absence of such information, traditional 0/1 distances for equal/nonequal minuatae can be utilized. The intersymbol distances between the minuatae can also be learnt using the training methodology explained earlier. Map Recognition In another embodiment, the method of this invention can be used to recognize maps. The maps are first preprocessed using standard image processing preprocessing operations (see Haralick and Shapiro {Computer and Robot Vision (1992))) and described in terms of their distinguishing features (landmarks) such as stop signs, yields, stop lights, bridges, railroad crossings etc. This is the straightforward necessary step and is usually available in most geographical information systems. The maps are recognized from their noisy subportions which may or may not be contiguous. These noisy subportions are also described in terms of their component distinguishing features after the same preprocessing. Since numerous tree representations of each map are possible, each map is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the map sought for is also mapped into a set of representative tree structures. The map recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each map and the tree representations of the noisy fragment Figure 23 is a schematic diagram showing how the invention can be used in the recognition of maps. The implementation of the invention to this problem domain is straightforward by specifying the intersymbol distances between the respective types of distinguishing features. These distances can be specified in terms of the likelihood of one distinguishing feature being transformed into (misrepresented by) another, and is related to the characteristics of the image processing environment of the GIS system which recognizes the distinguishing features themselves from the "raw" image. Again, in the absence of such information, traditional 0/1 distances for equal/nonequal distinguishing landmarks can be utilized. The intersymbol distances can also be learnt using the training methodology explained earlier. Recognition of Electronic Circuitry The method of this invention can be used to recognize electronic circuitry. The circuits are first preprocessed and described in terms of their components and wiring diagrams which form the nodes and edges of the underlying graph. The nodes in this case are the various electronic components such as resistors, diodes, transistors, capacitors etc. Obtaining this representation is the straightforward  since most circuits are designed on paper (or in a computer) before they are implemented in hardware. The circuits are recognized from their noisy subportions which may or may not be contiguous. Thus the portion of the circuit available may come from different portions of the circuit to be recognized. Since numerous tree representations of each electronic circuit are possible, each electronic circuit is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the electronic circuit sought for is also mapped into a set of representative tree structures. The electronic circuitry recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each electronic circuit and the tree representations of the noisy fragment. Figure 24 is a schematic diagram showing how the invention can be used in this application domain. The implementation of the invention to this problem domain is straightforward by specifying the intersymbol distances between the respective types of components. These distances can be specified in terms of the likelihood of one component (resistor, diode etc.) being transformed into (misrepresented by) another, and is related to the characteristics of the hardware setup which recognizes the components themselves from the actual circuit or printed circuit board. Again, in the absence of such information, traditional 0/1 distances for equal/nonequal components can be utilized. As before, the intersymbol distances can also be learnt using the training methodology explained earlier Recognition of Flow Charts The method of this invention can be used to recognize flow charts. The flow charts are first preprocessed and described in terms of their graphical features (the symbolic icons) which form the nodes of the underlying graph. The nodes in this case are the various symbols used in flow charting such as assignments, loops, comparisons, control structures etc. Obtaining this representation is the straightforward  since most flow charts are drawn on paper (or in a computer) before they are implemented in software. The flow charts are recognized from their noisy subportions which may or may not be contiguous. Since numerous tree representations of each flow chart are possible, each flow chart is first mapped into a set of representative tree structures. Similarly, the noisy fragment of the flow chart sought for is also mapped into a set of representative tree structures. The flow chart recognition is achieved by invoking the solution to the NSuT problem between the various tree representations of each flow chart and the tree representations of the noisy fragment. Figure 25 is a schematic diagram showing how the invention can be used in the recognition of flow charts. The implementation of the invention to this problem domain is straightforward by specifying the intersymbol distances between the respective types of flowcharting iconic symbols. These distances can be specified in terms of the likelihood of one symbol being transformed into (misrepresented by) another. As usual, in the absence of such information, they can be learnt using the training process explained earlier or traditional 0/1 distances for equal/nonequal iconic symbols can be utilized. Other Applications of the Invention Apart from the above applications, studies in compiler construction have also used treecomparison algorithms in automatic error recovery and correction of programming languages [Ta79]. Indeed the method of this invention can be used in any problem domain involving the comparison of treepatterns with other treepattems representing a noisy subpattern which has been "occluded" at multiple junctures. In one embodiment of the method of the present invention can be applied to the fundamental problem of data mining in areas where current day technology is not applicable. Typically, the data to be mined is represented symbolically. Current day syntactic data mining tools would seek for patterns in which the relationship between the symbols in the data is governed by a lefttoright or righttoleft ordering. The method of this invention would be capable of mining the data where the relationship between the symbols in the data is governed by both a lefttoright (or righttoleft) ordering and a latent parentchild relationship. Thus, the method could be used to discover patterns which are actually governed by a tree relationship, but which relationship is occluded by the string representation of the data to be mined. As an example, consider the problem where the data to be mined searches for repeated patterns of a phone prefix "4892676". The method of the invention can search for the pattern where the pattern sought for is distributed over a larger supersequence as "4abcbfsjd2iejf6iejfif6M. Furthermore, this supersequence could also be noisy, for example, "4abcbfsjd2iejf6iejfif3'In one embodiment the method of the present invention can be used in musical applications. Consider the scenario in which a user is searching for a musical piece in a music library. The user intends to discover a musical piece, but the input to the search mechanism would be a poorly played (for example, by playing on a keyboard) version of only a segment of one "part" (as in suprano, alto, tenor and bass) of the score. Furthermore, neither these segments nor the individual notes need be contiguous. The method of this invention can be used to search for and present the user with the best score in the library that contains the poorly played segment as a subscore or as a sequence of incorrectly played notes. The notes of the score could be the symbols in the alphabet, and each "part" could be treated as a separate sequence of notes which collectively describe the concerned score. In this case, the method of the invention would work with the string (i.e., the unidimensional lefttoright) representation since the tree representation is superfluous. However, it is important to point out that the string representation can be mapped to a tree representation by each node having only a single child. It is clear that the methodology used in all the above application areas is analogous. Indeed, the implementation in any one application domain can easily be modified for another application domain. In order to clarify issues however, we have implemented a prototype of the invention for the case of chemical compounds represented in terms of their atoms. Each compound is represented by 10 representative spanning trees. Noisy fragments of these compounds are then chosen and each fragment is represented by 3 possible representative spanning trees. The PR is achieved by invoking the NsuT recognition solution between the former trees and the trees representing the fragments. The prototype is amazingly accurate although the accuracy cannot be explicitly quoted since it intended for use in an online manner. EXAMPLES Example I The NsuT Recognition technique developed in the previous sections has been rigorously tested to verify its capability in the pattern recognition of NSuTs. The experiments conducted were for two different data sets which were artificially generated. To test the methods adequately, "relatively long" character sequences using benchmark results involving keyboard character errors have been resorted to. It will presently be made clear that these results are sufficient to demonstrate the power of the strategy to recognize noisy subsequence trees. It would be a rather trivial and straightforward exercise for an expert in the field to obtain equivalent results for biological molecules and for the other applications explained herein. The results obtained for simulated trees are the first reported results that demonstrate that a tree can indeed be recognized by processing the information resident in one of its noisy random subsequence trees. The details of the experimental setups and the results obtained follow. Tree Representation In the implementation of the method the invention, the tree structures of the patterns were studied as parenthesized lists in a lefttoright postorder fashion. Thus, a tree with root 'a' and children B, C and D is represented as a parenthesized list L = (B C D 'a') where B, C and D can themselves be trees in which cases the embedded lists of B, C and D are inserted in L. A specific example of a tree (taken from the dictionary) and its parenthesized list representation is given in Figure VI. In the first experimental setup the dictionary, H, consisted of 25 manually constructed trees which varied in sizes from 25 to 35 nodes. An example of a tree in H is given in Figure VI. To generate a NSuT for the testing process, a tree X* (unknown to the classification process) was chosen. Nodes from X* were first randomly deleted producing a subsequence tree, U. In the experimental setup the probability of deleting a node was set to be 60%. Thus although the average size of each tree in the dictionary was 29.88, the average size of the resulting subsequence trees was only 11.95. The garbling effect of the noise was then simulated as follows. A given subsequence tree U, was subjected to additional substitution, insertion and deletion errors, where the various errors deformed the trees as described earlier. This was effectively achieved by passing the string representation through a channel causing substitution, insertion and deletion errors analogous to the one used to generate the noisy subsequences by Oommen in (fEEE Trans. Pattern Anal, and Mack Intell., Vol. PAMI 9, No. 5 : pp. 676685 (1987)) and which has recently been formalized by Oommen and Kashyap (see {Pattern Recognition, Vol. 31, pp. 11591177 (1998))). However, as opposed to merely mutating the string representations as in this reference, the underlying list representation of the tree was manipulated. This involves ensuring the maintenance of the parent/sibling consistency properties of a tree which are far from trivial. In the specific scenario, the alphabet involved was the English alphabet, and the conditional probability of inserting any character a € A given that an insertion occurred was assigned the value 1/26. Similarly, the probability of a character being deleted was set to be 1/20. The table (Table I) of probabilities for substitution (the confusion matrix) was based on the proximity of the character keys on a standard QWERTY keyboard and is given in Figure 26. The channel essentially mutated the nodes (characters, in this case) in the list ignoring the parenthesis, and whenever an insertion or a deletion was introduced special case scenarios were considered so as to insert the additional required parenthesis or remove the superfluous parenthesis respectively. Furthermore, the maintenance of the parenthesis was done in such a way that the underlying expression of parenthesis was wellmatched. In the experiments ten NSuTs were generated for each tree in H yielding a test set of 250 NSuTs. The average number of tree deforming operations done per tree was 3.84. Table n, presented in Figure 27 gives a list of 5 of the NSuTs generated, their associated subsequence trees and the trees in the dictionary which they originated from. A larger subset of the trees used for these experiments and their noisy subsequence trees (both represented as parenthesized lists) are included in Table III, which is presented as Figure 28. Table IV gives the average number of errors involved in the mutation of a subsequence tree, U. Indeed, after considering the noise effect of deleting nodes from X* to yield U, the overall average number of errors associated with each noisy subsequence tree is 21.76. Table IV: The noise statistics .associated with the set of noisy subsequence trees used in testing. Every element, Y, in the set of noisy subsequence trees, was compared against the trees in H using the techniques described earlier. The results that were obtained were remarkable. Out of the 250 noisy subsequence trees tested, 232 were correctly recognized, which implies an accuracy of 92.80%. This is quite overwhelming.considering the fact that the items concerned are 2dimensional objects with an unusually high (about 73%) error rate at the node and structural level. Example II: In the second experimental setup, the dictionary, H, consisted of 100 trees which were generated randomly. Unlike in the above set (in which the treestructure and the node values were manually assigned), in this case the tree structure for an element in H was obtained by randomly generating a parenthesized expression using the following stochastic contextfree grammar G, where, G = N = {T, S, $} is the set of nonterminals, A is the set of terminals  the English alphabet, G is the stochastic grammar with associated probabilities, P, given below: Note that whereas a smaller value of pi yields a more treelike representation, a larger value of pi yields a more stringlike representation. In the experiments the values of pi and p2 were set to be 0.3 and 0.6 respectively. The sizes of the trees varied from 27 to 35 nodes. Once the tree structure was generated, the actual substitution of '$' with the terminal symbols was achieved by using the benchmark textual data set used in recognizing noisy subsequences by Oommen (IEEE Trans. Pattern Anal and Mack. IntelL, PAMI 9 : pp. 676685 (1987)). These textual strings consisted of a hundred strings taken from the classical book on pattern recognition by Duda and Hart (Pattern Classification and Scene Analysis, John Wiley and Sons, New York, (1973)).Each string was the first line of a section or subsection of the book, starting from Section 1.1 and ending with Section 6.4.3. Further, to mimic a UNIX/TEX file, all the Greek symbols were typed in as English strings. Subsequently, to make the problem more difficult, the spaces between words were eliminated, thus discarding the contextual information obtainable by using the blanks as delimiters. Finally, these strings were randomly truncated so that the length of the words in the dictionary was uniformly distributed in the interval [40, 80]. Thus, the first line of Section 3.4.1 of Duda and Hart (Pattern Classification and Scene Analysis, John Wiley and Sons, New York, (1973)), which reads "In this section we calculate the a posteriori density p{&X) and the desired probability" yielded the following string: " inthissectionwecalculatetheaposterioridensitypthetaxandthedesiredpro". The question of how the above strings are transformed into parenthesized list representations for trees is now considered. The trees generated using the grammar, and the strings considered were both traversed from left to right, and each '$' symbol in the parenthesized list was replaced by the next character in the string. Thus, for example, the parenthesized expression for the tree for the above string was: ((((((((((($)$)$)(($)$)$)$)$)$)((((($)($)$)$)$)((($)($)(($)$)$)$)$)$)$)$)$) The '$"s in the string are now replaced by terminal symbols to yield the following list ((((((((((((i)n)t)h)((i)s)s)e)c)t)((((((i)o)((n)w)e)c)a)((((l)c)((u)l)(((a)t)e)t)h)e)a)p)o)s) The actual underlying tree for this string is given in Figure VII. To generate a NSuT for the testing process, as in the above experimental setup, a tree X* (unknown to the PR system) was chosen. Nodes from X* were first randomly deleted producing a subsequence tree, U. In the present case the probability of deleting a node was set to be 60%. Thus although the average size of each tree in the dictionary was 31.45, the average size of the resulting subsequence trees was only 13.42. The garbling effect of the noise was then simulated as in the earlier setup. Thus the subsequence tree U, was subjected to additional substitution, insertion and deletion errors by passing the string representation through a channel causing substitution, insertion and deletion errors as described earlier while simultaneously maintaining the underlying list representation of the tree. Here too the alphabet being the English alphabet, the probabilities of insertion, deletion and the various confusion substitutions were as described earlier and were based on the QWERTY keyboard. In the experiments five NSuTs were generated for each tree in H yielding a test set of 500 NSuTs. The average number of tree deforming operations done per tree was 3.77. Table V gives the average number of errors involved in the mutation of a subsequence tree, U. Indeed, after considering the noise effect of deleting nodes from X* to yield U, the overall average number of errors associated with each noisy subsequence tree is 21.8. The list representation of a subset of the hundred patterns used in the dictionary and their NSuTs. is given in Table VI, which is presented as Figure 29. Table V: The noise statistics.associated with the set of noisy subsequence trees used in testing. Again, each noisy subsequence tree, Y, was compared against the trees in H using the constrained tree distance with the constraint x ={Lpl, Lp, Lp+1}. The results that were obtained are very impressive. Out of the 500 noisy subsequence trees tested, 432 were correctly recognized, which implies an accuracy of 86.4%. The power of the scheme is obvious considering the fact that the objects involved are 2dimensional objects with an unusually high (about 69.32%) error rate. Also, the corresponding unidimensional problem (which only garbled the strings and not the structure) gave an accuracy of 95.4% (See Oommen (JEEE Trans. Pattern Anal and Mach. IntelL, Vol. PAMI 9, No. 5 : pp. 676685 (1987))). REFERENCES [AHU74] A. V. Aho, J. E. Hopcroft and J. D. Ullman, The Design and Analysis of Computer Algorithms, Addison Wesley, Reading : MA, (1974). [CL85] Y. C. Cheng and S. Y. Lu, "Waveform correlation by tree matching", IEEE Trans. PAMI, Vol: PAMI 7, pp 299305 (1985). [DH731 R. O Duda and P. E. Hart, Pattern Classification and Scene Analysis, John Wiley and Sons, New York, (1973). [DH80] P. A. V. Hall and G. R. Dowling, "Approximate string matching", CompuL Sun, Vol 12 : pp 381402 (Dec 1980). [HS92] R. M. Haralick and L. G. Shapiro, Computer and Robot Vision, Addison Wesley, Reading, Mass. (1992). [LW75] R. Lowrance and R. A. Wagner, "An extension of the stringtostring correction problem", /. ACM, Vol 22: pp 177183 (April 1975). [Lu79] S. Y. Lu, "A treetotree distance and its application to cluster analysis", IEEE Trans. Pattern Anal, and Mach. IntelL, Vol. PAMI 1, No. 2: pp. 219224 (1979). [Oo86] B. J. Oommen, "Constrained string editing", Inform, Sci., Vol. 40 : pp. 267284 (1986). [Oo87] B. J. Oommen, "Recognition of noisy subsequences using constrained edit distances", IEEE Trans. Pattern Anal, and Mack Intell, Vol. PAMI 9, No. 5 : pp. 676685 (1987). [OK98] B. J. Oommen and R. L. Kashyap, "A formal theory for optimal and information theoretic syntactic pattern recognition", Pattern Recognition, Vol. 31, pp. 11591177(1998). [OL94] B. J. Oommen and W. Lee, "Constrained Tree Editing", Information Sciences, Vol. 77 No. 3,4: pp. 253273 (1994). [OL97] B. J. Oommen and R. K. S. Loke, "On Using Parametric String Distances and Vector Quantization in Designing Syntactic Pattern Recognition Systems", Proceedings of the 1997 IEEE International Conference on Systems, Man and Cybernetics, Orlando, Florida, October, pp. 511517 (1997). [OZL96] B. J. Oommen, K. Zhang, and W. Lee, "Numerical Similarity and Dissimilarity Measures Between Two Trees", IEEE Transactions on Computers, Vol.TC45, pp.14261434 (1996). [SK83] D. Sankoff and J. B. Kruskal, Time wraps, string edits, and macromolecules : Theory and practice of sequence comparison, AddisonWesley, (1983). [Se77] S. M Selkow, "The treetotree editing problem", Inf. Proc. Letterrs, Vol 6, No. 6, pp 184186 (Dec. 1977). [Sh88] B. Shapiro, "An algorithm for comparing multiple RNA secondary structures", CompuL Appl. Bioscu, 387393 (1988). [SZ90] B. Shapiro and K. Zhang, "Comparing multiple RNA secondary structures using tree comparisons", Comp. AppL Biosci. Vol. 6, No. 4, pp. 309318, (1990). [Ta79] K. C. Tai, "The treetdtree correction problem", J. ACM, Vol 26, pp 422433 (1979). [WF74] R. A. Wagner and M. J. Fischer, "The stringtostring correction problem", J. Assoc. CompuL Mack, Vol. 21: pp. 168173 (1974). [Zh90] K. Zhang, "Constrained string and tree editing distance", Proceeding of the IASTED Internationa! Symposium, New York, pp. 9295 (1990). [ZJ94] K. Zhang and T. Jiang, "Some MAX SNPhard results concerning unordered labeled trees", Information Processing Letters, 49, 249254 (1994). [ZS89] K. Zhang and D. Shasha, "Simple fast algorithms for the editing distance between trees and related problems", SIAM J. Comput. Vol. 18, No. 6 : pp. 12451262 (1989). [ZSS92] K. Zhang, R. Statman, and D. Shasha, "On the editing distance between unordered labeled trees", Information Processing Letters, 42,133139 (1992). [ZSW92] K. Zhang, D. Shasha and J. T. L. Wang, "Fast serial and parallel approximate tree matching with VLDCs", Proceedings of the 1992 Symposium on Combinatorial Pattern Matching, CPM92,148161 (1992). We claim: . 1. A method of comparing the closeness of a target structure to other structures in a set of candidate structures, the method comprising the steps of: a. creating a target tree representative of the target structure, the target tree having at least one node which has at least two branches; b. creating a database of candidate trees, each candidate tree in the database of candidate trees representing a candidate structure in the set of candidate structures and each candidate tree in the database of candidate trees having at least one node which has at least two branches and selecting a set of candidate trees from the database of candidate trees; c. comparing a closeness of the target tree to each candidate tree in the selected set of candidate trees, wherein the step of comparing the closeness of the target tree to each candidate tree in the selected set of candidate trees, further comprises the following substeps (d), (e), and (f); d. calculating a constraint in respect of each candidate tree in the selected set of candidate trees based on an estimated number of edit operations and a characteristic of the target tree; e. calculating a constrained tree edit distance between the target tree and each candidate tree in the selected set of candidate trees using the constraint obtained in step (d); and f. comparing the calculated constrained tree edit distances. 2. The method as in claim 1, wherein the step of calculating a constrained tree edit distance also uses the intersymbol edit distance. 3. The method as in claim 1 or 2, wherein the target tree is a noisy sub fragment of a candidate tree located in the selected set of candidate trees. 4. The method as in claim 1, 2 or 3 wherein step (d) is preceded by the process of estimating the probability of an edit operation being performed on a nocje value so as to transform each candidate tree in the selected set of candidate trees into an arbitrary noisy version of that candidate tree. 5. The method as in claim 4, wherein the edit operation which is used to calculate the constraint is a substitution operation. 6. The method as in claim 4, wherein the edit operation which is used to calculate the constraint is an insertion operation. 7. The method as in claim 4, wherein the edit operation which is used to calculate the constraint is a deletion operation. 8. A method of matching a target tree representable structure to its closest candidate tree representable structure, said method comprising the steps: a. generating a target tree representative of the target structure; b. generating a database of candidate trees, each candidate tree being representative of a candidate tree representable structure; c. calculating a constraint in respect of each candidate tree in the database based on an estimated number of edit operations and a characteristic of the target tree; d. calculating a constrained tree edit distance between the target tree and each candidate tree in the database using the constraint obtained in step (c) and the intersymbol edit distance; e. comparing the calculated constrained tree edit distances; and f. reporting the candidate tree in the database that has the smallest constrained tree edit distance. 9. The method as in claim 8, wherein the step of calculating a constrained tree edit distance also uses the intersymbol edit distance. 10. The method as in claim 8 or 9, wherein the target tree is a noisy subfjjagpiehf of a candidate tree located in the database of candidate trees. 11. The method as in claim 8, 9 or 10 wherein step (c) is preceded by the process of estimating the probability of an edit operation being performed on a node value so as to transform each candidate tree in the database of candidate trees into an arbitrary noisy version of that candidate tree. 12. The method as in claim 11, wherein the edit operation which is used to calculate the constraint is a substitution operation. 13. The method as in claim 11, wherein the edit operation which is used to calculate the constraint is an insertion operation. 14. The method as in claim 11, wherein the edit operation which is used to calculate the constraint is a deletion operation. Dated this 22nd day of April 2002 The present invention provides a method of comparing the closeness of a target tree to other trees located in a database of trees, said method comprising the steps of (a) calculating a constraint in respect of each tree in the database based on an estimated number of edit operations and a characteristic of the target tree (b) calculating a constrained tree edit distance between the target tree and each tree in the database using the constrained obtained in step (a); and (c) comparing the calculated constrained tree edit distances. The method of this invention can also be applied to matching a target tree representable structure to its closest tree representable structure. 

inpct2002497kolabstract.pdf
inpct2002497kolclaims.pdf
INPCT2002497KOLCORRESPONDENCE.pdf
inpct2002497kolcorrespondence1.1.pdf
inpct2002497koldescription (complete).pdf
inpct2002497koldrawings.pdf
inpct2002497kolexamination report.pdf
inpct2002497kolexamination report1.1.pdf
inpct2002497kolform 1.pdf
inpct2002497kolform 18.1.pdf
inpct2002497kolform 18.pdf
inpct2002497kolform 2.pdf
inpct2002497kolform 3.1.pdf
inpct2002497kolform 5.1.pdf
inpct2002497kolform 5.pdf
inpct2002497kolgrantedabstract.pdf
inpct2002497kolgrantedclaims.pdf
inpct2002497kolgranteddescription (complete).pdf
inpct2002497kolgranteddrawings.pdf
inpct2002497kolgrantedform 1.pdf
inpct2002497kolgrantedform 2.pdf
inpct2002497kolgrantedspecification.pdf
inpct2002497kolothers.pdf
inpct2002497kolreply to examination report.pdf
inpct2002497kolreply to examination report1.1.pdf
inpct2002497kolspecification.pdf
Patent Number  244347  

Indian Patent Application Number  IN/PCT/2002/497/KOL  
PG Journal Number  49/2010  
Publication Date  03Dec2010  
Grant Date  02Dec2010  
Date of Filing  22Apr2002  
Name of Patentee  OOMMEN, JOHN, B.  
Applicant Address  5942, 3RD LINE ROAD, NORTH GOWER, ONTARIO KOA 2TO  
Inventors:


PCT International Classification Number  G06K 9/68  
PCT International Application Number  PCT/CA2000/01107  
PCT International Filing date  20000929  
PCT Conventions:
