JP2005316605A - Splicing pattern analysis method of biopolymer alignment - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To efficiently extract a partial alignment corresponding to an individual exon from a number of biopolymer alignment data including alignments mutually having a relation of splicing variant while considering a case a plurality of exons of a same alignment appear on a same input alignment. <P>SOLUTION: A model of an exon alignment considering the case the plurality of the exons of the same alignment appear on the same input alignment is constructed by using a condition to be satisfied by the exon alignment. The exon alignment defined by the model is extracted from a biopolymer alignment given as input. According to this method, a suffix tree is constructed based on the given biopolymer alignment, and a processing related to search of depth priority on the suffix tree and a position of each character in the alignment is performed in a frequency independent from the number of characters in the alignment or the number of alignments, whereby extracting processing can be completed in a linear time to a total sum of length of the biopolymer alignment given as the input. <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention relates to a character string analysis method for extracting a plurality of character strings, particularly partial character strings that are commonly present in a biopolymer sequence, and relates to a method suitable for application to a splicing pattern analysis method for biopolymer sequences. .

  The completion of character sequencing of the human genome was declared in June 2000 by an international joint project and a US venture company. While genome sequence analysis is progressing, mRNA is being analyzed to investigate the expressed genes. mRNA is an RNA molecule generated from genomic DNA when a gene is expressed, and is an indispensable substance in the process of gene function expression. Since mRNA molecules are easily degraded, they are often analyzed by reverse transcription into cDNA, which is a more stable substance than mRNA. The cDNA sequence obtained by sequencing cDNA has various utility values, one of which is to clarify what exons the gene is composed of.

MRNAs derived from the same gene but having different splicing regions are said to be splicing variants. In the case of humans, it is said that there are more than 100,000 types of proteins in the living body, but the number of genes is said to be only 30,000 to 40,000, and splicing variants are thought to fill this difference. Such splicing variant analysis is inevitable in analyzing the functional expression of genes, and is indispensable for elucidation of biological phenomena and genome drug discovery. Collecting and analyzing sufficient amounts of cDNA sequences to cover all splicing variant sequences from the same gene is a powerful tool to elucidate the exon structure of mRNA. In order to analyze splicing variants based only on sequences derived from transcripts such as cDNA sequences, the issue is how to extract partial sequences corresponding to individual exons from multiple sequences. However, when taking the approach of exhaustively enumerating all the partial sequences of a given sequence and checking whether it is an exon sequence, there is a partial sequence of the order of the square of the sequence length for each input sequence. When the comparison is made between a plurality of input arrays, at least a calculation time of an order obtained by further multiplying the number of given arrays is required. Therefore, as the amount of data to be processed increases, the time required for processing increases rapidly, making it difficult to create a practical system. On the other hand, the number of sequences called ESTs obtained by sequencing a portion of cDNA accumulated in a database of a US public organization is rapidly increasing with the progress of sequencing technology. Just over 4.5 million sequences. In order to analyze such a large amount of sequence data, a high-speed calculation method is required.
Conventional techniques for performing comparative analysis of sequences include the following.

  The homology search method of Non-Patent Document 1 is also used for cDNA sequence analysis. If a genomic sequence can be used in addition to the cDNA sequence, it can be predicted with high accuracy that the partial character string of the genomic sequence is an exon. However, when analyzing cDNA sequences that do not have corresponding genomic sequences, it is necessary to perform a mutual comparison between sequences derived from transcripts. In the method of homology search, if cross-comparison between sequences is performed in the brute force, the calculation time in the order of the square of the number of sequences is necessary in the worst case, and the splicing pattern is analyzed when the number of sequences increases. Is difficult.

As a method for efficiently extracting a partial sequence common to a plurality of sequences, the method of Delcher et al. In Non-Patent Document 2 is known. Delcher's approach is primarily aimed at comparing the genomes of two closely related species. In this method, first, a partial sequence called MUM (Maximal Unique Match) that satisfies the following conditions (D1)-(D4) is searched.
(D1) MUM is a partial array whose length is greater than or equal to the parameter specified by the user.
(D2) MUM is a common partial array of two arrays.
(D3) Only one MUM is included in each of the two arrays.
(D4) A MUM is not a subarray of another MUM. That is, only the sequence obtained by extending the sequence satisfying (D1)-(D3) as much as possible is MUM.

  If the method of Delcher et al. Is applied to the cDNA sequence and the part to be aligned as MUM and the position where a large insertion or deletion is inserted are identified, MUM corresponds to the exon sequence, and large insertion or deletion is a selective exon. Can be considered as a tool for identifying exon structures. However, the method of Delcher et al. Applies only to two sequences and cannot be applied when the number of sequences becomes 3 or more. Also, it is generally not guaranteed that exons of the same sequence do not appear in the same sequence. Delcher et al., In Non-Patent Document 3, have developed a method to make the suffix tree implementation compact and store only one array in the suffix tree, but cannot simultaneously compare three or more arrays. Is unresolved.

  As a method for extracting a common partial sequence from three or more character strings, a linear time solution to the longest common substring problem described in chapter 9 of Non-Patent Document 4 is known. If this method is used, the longest partial character string among the partial character strings common to the specified number or more of character strings can be extracted with a linear time of the total number of characters. However, since only the longest common substring can be extracted, and strings that overlap each other may be extracted, the sequence extracted by this method corresponds to an exon. You can't think of it as an array.

  Hohl et al. Mainly used for alignment of genome sequences, extracted partial sequences common to three or more sequences, aligned the extracted partial sequences, and aligned multiple sequences based on the results. A method of generating at high speed was developed (Non-Patent Document 5). However, Hohl et al.'S method targets only sequences common to all sequences and cannot extract sequences common to only a part of the sequences. Therefore, when applied to splicing variant sequences, alternative splicing is not possible. There is a problem that exons to be performed cannot be extracted.

Altschul, S.F. et al., Nucleic Acid Research, 25: 3389-3402, 1997 Delcher et al., Nucleic Acids Research, 1999, 27 (11): 2369-2376 Delcher et al., Nucleic Acids Research, 2002, 30 (11): 2478-2483 Gusfield, D., Algorithms on Strings, Trees, and Sequences: Computer Science and Computational Biology, Cambridge University Press, New York Hohl, M., Kurtz, S., and Ohlebusch, E., Efficient multiple genome alignment, Bioinformatics 18 Suppl.1, S312-S320, 2002

  An object of the present invention is to extract exon sequences contained in these sequences based on a plurality of sequences derived from transcripts.

  Ideally, it would be ideal to be able to fully identify the sequences of individual exons based solely on transcript-derived sequences, but in reality this is not always possible. A gene has four exons A, B, C, and D, and these exons are arranged on the genome in this order. As shown in Fig. 14, if B and C always appear in mRNA through the process of splicing, as long as only the cDNA sequence is seen, there are two other exons B and C, and the cDNA sequence. It is impossible to know where the boundary of B and C is above. In addition, as shown in FIG. 15, let us consider a case where exon A is always accompanied by B or C immediately after, and B and C are always preceded by A. If the leading sequences of B and C match, you can know the existence of the three exons A, B, and C, but you cannot know where A, B, and C are. Therefore, the present invention aims to identify the longest sequence that is a partial sequence of sequences in which exons that always coexist adjacent to each other are linked and does not contain bases derived from other exons. Such a partial sequence is hereinafter referred to as Exon Group (EG). By the way, a partial sequence whose length is extremely short, such as about several characters, appears everywhere on the input sequence and can be a partial sequence common to a plurality of input sequences, but they should not be regarded as exon sequences. Therefore, EG should be a partial sequence longer than a certain length.

  In order to describe the method of extracting EG, it is necessary to strictly define the EG intuitively explained above. To prepare for this, we define three concepts. In addition, the following description is applied as it is even when handling other types of character strings such as amino acid sequences as well as base sequences. Therefore, in the following, in order to clarify that a wider problem can be handled, the word string is used instead of the sequence and the word character is used instead of the base.

The first definition is a strict definition in this specification that “character strings overlap”. In this specification, as shown in FIG. 13, when and only when there is a character string t, t ′, t ″ that satisfies the following four conditions, “character string s, s ′ Are said to overlap.
(1) t, t ', t''are all character strings with a length of 1 or more.
(2) s = tt ', that is, s is a string that concatenates t and t'.
(3) s' = t't '', that is, s' is a character string that concatenates t 'and t''.
(4) An input character string includes tt't '' as a substring.
When (1)-(4) is satisfied, it is said that "s overlaps s 'on the right" and "s' overlaps s on the left".

The second definition is a set Q (s) of positions in the input string where the string s appears. Q (s) is defined by the following equation.
Q (s) = {(i, j) | s is a string starting from the jth base of the given ith string}
The following operations are defined for Q (s) and integer k.
Q (s) + k = {(i, j + k) | (i, j) ∈Q (s)}, Q (s) −k = Q (s) + (− k)
Note that the element (i, j) of Q (s) is referred to as the appearance of s in this specification.

The third definition is the definition of the string maximum match (MM), which may be a concatenation of multiple exon sequences. In the present specification, a character string that satisfies the conditions (M1)-(M4) is hereinafter referred to as MM.
(M1) A substring of one or more strings.
(M2) Length u or more. However, u is the length of the shortest exon to be extracted by the method of the present invention, and is an integer given as a parameter by the user of the method of the present invention.
(M3) For any character a appearing in the input character string, Q (m) ≠ Q (ma). Here, ma is a character string in which the character a is added to the end of the character string m.
(M4) For any character a appearing in the input character string, Q (m) ≠ Q (am) +1. Here, am is a character string in which the character a is added to the head of the character string m.

FIG. 3 shows an example of MM.
EG 305 should be a string that does not completely contain or overlap MM 303 as a substring. Therefore, EG is defined as a character string that satisfies the following conditions.
(E1) A substring of at least one input string.
(E2) Length u or more.
(E3) Does not overlap with MM.
(E4) MM is not a true substring. A true partial character string of a character string is a partial character string other than the character string itself.
(E5) Does not become a true substring of a character string that satisfies (E1)-(E4).

  In order to efficiently process large amounts of data, it is desirable to minimize the processing time. Since the linear time of the total number of characters is required to read the input character string, if the processing time is limited to the linear time, the theoretically most efficient calculation time order is realized. Based on the above, the problem of the present invention is that when a character string corresponding to a plurality of biopolymer sequences is given, a character string that satisfies (E1)-(E5), that is, EG, is given as a given input character string. It is to provide a method of extracting in the linear time of the total number of characters.

  In the present invention, when a plurality of character strings 301 are given as input, a right MM 302 (to be described later), a left MM or MM 303 (to be described later), and a right EG-holder 304 (to be described later) are sequentially extracted. To extract. Note that only one of the left MM extraction (step S503) and the MM extraction (step S504) may be performed.

The features of the present invention will be described below.
The method of the present invention is a method of extracting EG when a plurality of input character strings are given, and can complete the processing in a linear time with respect to the total number of characters of the input character string.

  The method of the present invention includes a step of extracting right MM, a step of extracting MM or the above-mentioned left MM, and a step of extracting right EG-holder in order to extract EG. In each process, a suffix tree storing an input character string is used.

  The method of the present invention is also characterized in that, in the step of extracting MM, the right MM is extracted, and a partial character string satisfying the condition of MM is selected and extracted.

  The method of the present invention is also characterized by having a step of extracting the right EG-holder.

  In the method of extracting the right EG-holder, the method of the present invention also calculates only the position of the right MM that does not make the other right MM a true suffix in order to analyze the position of the MM on the input character string. Alternatively, only the position of the right MM that does not make the other right MM a true prefix is calculated.

  In the method of the present invention, when a right MM that does not use another right MM as a true suffix is obtained, if the node on the suffix tree corresponding to the right MM is a leaf node, the suffix link of the parent node of the node It is characterized by using.

  The method of the present invention is also characterized in that only the prefix of the right EG-holder is regarded as an EG candidate.

  According to the present invention, an EG can be extracted from a biopolymer sequence such as a cDNA sequence in a linear time of the sum of given sequence lengths.

  Hereinafter, embodiments of the present invention will be described. First, the symbols, terms and concepts used in this specification are defined. Note that the method of the present invention can be applied not only to base sequences but also to other types of character strings such as amino acid sequences. Therefore, in the following, in order to clarify that it is possible to handle a more general problem, the word “character” is used instead of the character string and the base instead of the sequence.

First, symbols and exact meanings used in this specification are defined for concepts that are already known.
● Null string A zero-length string. In the present specification, hereinafter, an empty character string is expressed as ε.
● Concatenation of character strings A character string obtained by concatenating character strings s and t is expressed as st.

● | s |
The length of the string s.
● s [j] (0 ≦ j <| s |)
The jth character in the string s. In the present specification, the first character of the character string is counted as the 0th character.

● s [i..j]
A substring of the string s that includes both the i-th character and the j-th character from the i-th character to the j-th character. When i> j, it is defined as s [i..j] = ε.
● Prefix
For the string s, s [0..j] (j ≦ | s |) is called the prefix of s.

● Suffix
For a character string s, s [j .. | s | −1] (j ≧ 0) is called suffix of s.
● | A |
Number of elements in set A

● ⊆, ⊇, ⊂, ⊃
In this specification, for the two sets A and B, “A⊆B” means that all elements of A are elements of B, and “A⊇B” means B⊆A. “A⊂B” means A⊆B and A ≠ B, and “A⊃B” means B⊂A.

O (f (n))
G (n) = O (f (n)) for function g (n) means that there is a constant C and that g (n) ≦ Cf (n) holds for sufficiently large n It is. Also, a certain quantity is “O (f (n))” means that the quantity is less than or equal to the function g (n) of n and g (n) = O (f (n)). To do.

Ω (f (n))
The expression g (n) = Ω (f (n)) means that there exists a certain constant C and that g (n) ≧ Cf (n) holds for a sufficiently large n. Also, a certain quantity is “Ω (f (n))” means that the quantity is not less than the function g (n) of n and g (n) = Ω (f (n)). To do.

● Suffix tree
The suffix tree of character strings P1, P2, ..., Pn is all that appear in P1 $, ..., Pn $ obtained by adding $ to the end of each character string for character $ that does not exist in P1, ..., Pn This is a tree-like data structure that stores the suffix of and has the following properties. A suffix tree 401 storing two character strings “ATATG” and “TTAGTA” is shown in FIG.
(S1) A directed tree having a root node 402.
(S2) P1 $, ..., Pn $ have the same number of leaves as the number of different suffixes. In the present invention, a set {(i, j)} of a pair (i, j) of a character string number i and a position j in the character string is associated with and stored in these leaves. It is assumed that the data structure can be accessed with O (1) by a pointer to the data structure.
(S3) A partial character string of any one of P1 $,..., Pn $ is added as a label 405 to each edge 404.
(S4) There is no edge pair having a label 405 starting with the same character at an edge starting from an arbitrary node 407.
(S5) When the labels of the edges on the path from the root node 402 to the leaf 403 to which the character string number i and the position j in the character string are assigned are connected in the order in which they are encountered on this path, j of the input character string i This is a string with a suffix of $ starting with the suffix starting with the second character.
(S6) The number of edges extending from an arbitrary node v is not 1.

  When the total number of characters in the character string stored in the suffix tree is n, the number of leaves 403 is n or less, so the number of nodes other than leaves is n−1 or less. Therefore, the number of nodes in the entire suffix tree is 2n-1 or less, and O (n). Note that an empty set φ is associated with a leaf that can be reached from the root node once through an edge with a label of “$”.

● Pass label
The path label of the node 407 in the suffix tree is a character string obtained by concatenating the edge labels on the path 408 from the root node 402 to this node 407.
● Suffix link
Let v be a non-leaf node of the suffix tree. When the path label of a node v can be expressed as as by a certain character a and a character string s, a pointer from v to a node whose path label is s is called a suffix link. In this specification, the suffix link of v is denoted as suffixlink (v). It is known that a node v (s) to be pointed to by suffixlink (v) always exists if the path label of v is as (Non-patent Document 4, chapter 6). 409 in FIG. 4 is an example of a suffix link. When there is no risk of misunderstanding, the notation “suffixlink (v)” may be identified with the node pointed to by suffixlink (v).

Next, symbols and terms used in this specification and concepts specific to this specification are defined below.
● Input character string (see 301 in Fig. 3)
A biopolymer sequence, such as a base sequence or amino acid sequence, provided as input to the method of the present invention.
● N
The total number of characters of the input character string to which the method of the present invention should be applied.
● k
The number of input strings to which the method of the present invention should be applied.
● u
A parameter given to the method of the present invention is an integer that specifies the length of the shortest character string that is considered to be an exon sequence.

P (v)
The path label for node v.
P '(v)
If $ exists at the end of the path label p (v) of node v, the character string obtained by removing the $. Otherwise, the same string as p (v).

● v (s)
A node whose path label is the string s.
● v '(s)
v (s $) if s appears only as a suffix of Si on any input string Si where s appears. Otherwise v (s).

● Σ
A set of all character types present in the input string.
● Si
i-th input string. However, 0 ≦ i <k.

● MM (see 303 in Fig. 3)
A character string that satisfies the above conditions (M1)-(M4).
● EG (See 305 in Fig. 3)
A character string that satisfies the above conditions (E1)-(E5).
● Right MM (see 302 in Fig. 3)

A character string that satisfies the following conditions (R1)-(R3) is called a right MM.
(R1) A substring of one or more input strings.
(R2) The length is not less than u.
(R3) The right MM r satisfies Q (r) ≠ Q (ra) for an arbitrary character a. That is, the right MM cannot be extended to the right.

For any right MM r, the longest character string s that may be an empty character string satisfying Q (sr) + | s | = Q (r) can be taken, and sr is (M1)-(M4) Since it satisfies, it is MM. Therefore, the following property (R4) holds.
(R4) For any right MM r, there is a MM m where r is a suffix and satisfies Q (m) + | m |-| r | = Q (r).

Also assume that the right MM r is the prefix of MM m. At this time, from Q (am) + 1⊂Q (m) for an arbitrary character a, (i, j-1) is not an appearance of am for an appearance (i, j) with m. Therefore, since Si [j-1] ≠ a, (i, j-1) is not an appearance of ar. However, since (i, j) is the appearance of m, it is also the appearance of r, which is its prefix. Therefore, Q (ar) + 1 ≠ Q (r). Therefore, r satisfies (M4) and is therefore MM. In other words, the following property (R5) holds for the right MM.
(R5) The right MM that is the prefix of MM is MM.

● Left MM
A character string that satisfies the following conditions (L1)-(L3) is called a left MM.
(L1) A substring of one or more input strings.
(L2) The length is not less than u.
(L3) The left MM l satisfies Q (l) ≠ Q (al) +1 for an arbitrary character a. That is, the left MM cannot be extended to the left.

● Right EG-holder (see 304 in Fig. 3)
A character string that satisfies the following conditions (H1)-(H3) is called a right EG-holder.
(H1) Right MM.
(H2) Either of the following (H2a) or (H2b) is satisfied.
(H2a) MM.
(H2b) A character string h such that there exists a certain MM m and mh is a partial character string of at least one input character string.
(H3) Does not have right MM as a true prefix.

  As described above, in the present invention, the right MM, the left MM or MM, and the right EG-holder are sequentially extracted, and the EG is extracted using the extraction results. FIG. 5 is a flowchart showing the entire processing according to the present invention. Hereinafter, a method for extracting the right MM, left MM, MM, right EG-holder, and EG will be described with reference to FIG.

■ Construction of Suffix tree T (Step S501)
In the method of the present invention, first, a suffix tree T is constructed based on the input character string. Suffix tree T can be constructed using Ukkonen's algorithm (Non-patent Document 4, chapter 6), including the process of setting all suffix links in O (N) processing time. Thereafter, the method of the present invention repeatedly executes depth-first search on the suffix tree T.

Extract right MM (step S502)
When depth-first exploration of Suffix tree T and encountering node v, the length of string p '(v) is greater than or equal to u, and the label of the edge from v's parent node to v is not "$" , V is marked as “right MM”. Note that the path label length | p (v) | can be calculated in constant time per node by holding the sum of the edge lengths in the path from the root node to v during depth-first search. | P '(v) | = | p (v) | −1 when the end of the edge label is $, and | p ′ (v) | = | p (v) |

When this processing is completed, p ′ (v) is the right MM for the node v marked as “right MM”, and only those are the right MM. Give the reason.
About (R1):
The path label p (v) of any node in suffix tree T is the suffix of the suffix of the character string Si $ with $ appended to the end of at least one input character string Si. Therefore, if $ exists at the end of p (v), the character string p ′ (v) from which $ is removed is a prefix of Si suffix and is a partial character string of at least one character string. Therefore, for node v marked as right MM, p ′ (v) satisfies (R1).
About (R2):
The node v marked as “right MM” in the method of the present invention is only the node with | p ′ (v) | ≧ u. Therefore, for such a node v, p ′ (v) satisfies (R2).
About (R3):
For a node v marked as “right MM”, no matter how the character a∈Σ is chosen, there is an appearance (i, j) with p ′ (v), and (i, j) is p It is not the appearance of '(v) a. This is because if there is no such appearance (i, j), the first letters of the edge labels coming from the node v are all a, which violates the suffix tree condition (S4). Therefore, p ′ (v) satisfies (R3).

  Furthermore, if p ′ (v) of the node v marked with the right MM is not used in the method of the present invention, it indicates that any of the conditions (R1)-(R3) is not satisfied.

  First, a character string that does not appear as a prefix of the path label of a suffix tree T node is not a substring of any input character string, and is contrary to (R1).

  Next, it is assumed that a node v ′ (r) does not exist for a character string r that is a prefix of a node and does not include $. If r appears only as a suffix of the input character string, v '(r) = v (r $) exists and violates the assumption, so r appears at a position other than the suffix of a certain input character string Si. That is, j + | r | <| Si | for an appearance (i, j) ∈Q (r). At this time, a = Si [j + | r |] is set. Since a is a character in Si, a∈Σ. Assuming that v '(r) = v (r) exists because there is both a path label with ra as a prefix and a path label with r $ as a prefix if r is a suffix of the input string Si. Contradict. So r is not a suffix of any input string. Assuming that there is an input character string with rb as a substring for a character b that is not a, there are both a path label with ra as a prefix and a path label with rb as a prefix, so v '(r) = v ( The existence of r) contradicts the assumption, and the existence of an input string with rb as a substring is denied. Therefore, since r always appears with the character a∈Σ on the right side in the input string, Q (r) = Q (ra). Therefore, r does not satisfy (R3).

  Furthermore, the method of the present invention does not mark the node v where | p ′ (v) | <u, but the character string p ′ (v) does not satisfy (R2) for such a node v.

  Other than the above, there is no character string other than p ′ (v) of the node v marked as “right MM”. That is, according to the method of the present invention, v ′ (r) can be marked as “right MM” without excess or deficiency for all right MM r.

■ Left MM extraction (step S503)
A suffix tree T is constructed in step S501, and the left MM is extracted in the same manner as the right MM is extracted in step S502. In addition, when extracting MM by step S504, step S503 which extracts left MM does not need to be performed.

  In step S503, in order to extract the left MM, a suffix tree T ′ is constructed for character strings obtained by viewing all input character strings in reverse order. For example, if the input character strings are ATATG and TTAGTA, a suffix tree T ′ is constructed for GTATA and ATGATT obtained by reversing these. Then, “suffix tree T” is replaced with “suffix tree T ′”, “right MM” is replaced with “left MM”, and the right MM extraction method of the present invention is executed. The fact that the left MM can be extracted without excess or deficiency by this method is clear from the fact that the right MM is extracted without excess or deficiency in step S502.

■ Extraction of MM (Step S504)
A method for extracting MM is described. If the left MM is extracted in step S503, step S504 for extracting the MM may not be performed.

All MMs satisfy (R1)-(R3) from (M1)-(M3) and are right MMs. For any right MM r, v '(r) is already marked as "right MM" in the above method, so when these r satisfy (M4), v' (r) Just mark “Yes”. In order to identify a node corresponding to the right MM that satisfies (M4), the “left diverse node” identification method described in P144 to P145 of Non-Patent Document 4 may be applied with the following modifications.
(1) The definition of node “v” that is “left diverse” in Non-Patent Document 4 is changed to “node v where p ′ (v) satisfies (M4)”.
(2) The leaf node v is not judged as “the leaf is not always“ left diverse ”” as in the method of Non-Patent Document 4. Instead, if a character a∈Σ exists, and j ≧ 1 and Si [j-1] = a holds for any appearance (i, j) of p '(v), the “left character” of v If a is not present, v is determined to be “left diverse”.
(3) For a node v that is not a leaf, if there is no “left diverse” node among the child nodes of v, and v∈ itself is uniquely determined by a∈Σ where all the child nodes have a “left character” It is assumed that “left character” of v is not “left diverse” but “a”, and v is “left diverse” otherwise.
(4) If a node determined to be “left diverse” is marked as “right MM”, mark it as “MM”.

  The computation time for this method is the order of the total number of appearances associated with the leaf and the number of nodes in suffix tree T. The former is equal to the sum N of the input string lengths, and the latter is 2N-1 or less, so the total processing time is O (N).

■ Extraction of MM end position (Step S505)
Using the right MM information extracted in step S502 and the left MM information extracted in step S503 or the MM information extracted in step S504, the two-dimensional arrays Head and Tail are set as follows in step S505. Head [i, j] and Tail [i, j] have values for (i, j) where 0 ≦ i <k and 0 ≦ j <| Si |.
Head [i, j]:
1 if there is an MM with an appearance of (i, j). 0 otherwise. (See Figure 7)
Tail [i, j]:
1 if there is an MM m whose appearance is (i, j- | m | +1). 0 otherwise. (See Figure 7)

First, two methods for setting the Tail value are described. The first method is to execute the following (t1)-(t3).
(t1) All elements of the two-dimensional array Tail 702 are initialized with 0.
(t2) The list minimal_right_MM is initialized with an empty list.
(t3) Depth-first exploration of suffix tree T, and process (t3a)-(t3c) for node v encountered.
(t3a) For the character a∈Σ and the character string s such that p ′ (v) = as, v ′ (s) is identified. If v is not a leaf, s does not contain $, so v '(s) = v (s) = suffixlink (v). If v is a leaf, the following processing is performed. First, at the time of depth-first search, the parent node of the node that is the processing target at that time is stored. If w is the parent node of leaf v, it is clear that w is not a leaf. Set w '= suffixlink (w). When moving on the suffix tree from w 'along the character string that is the edge label between wv, the node w''= v (s) is reached. If the edge label directly leading to w ″ is a single character string “$”, v (s) is the parent node of w ″, otherwise v ′ (s) = w ″.
(t3b) If v ′ (s) is not marked as “right MM”, add | p ′ (v) | to the end of the list minimal_right_MM. Note that the value added to the list minimal_right_MM is deleted when the processing of the subtree having the node v as the root node is completed. This deletion operation can be realized simply by deleting the last element of minimal_right_MM.
(t3c) When v is a leaf, Tail [i, j + k−1] 702 is set to 1 for an arbitrary appearance (i, j) associated with v and an arbitrary element k of the list minimal_right_MM.

  In this method, instead of directly calculating the position of the MM when setting the value of Tail, the end position of the character string r that is a right MM that does not have another right MM as a suffix (hereinafter referred to as a minimal right MM) Is calculated. That is, 1 is written in Tail [i, j + | r | -1] 702 for an arbitrary appearance (i, j) of r for an arbitrary minimal right MM r. The set of end positions of all minimal right MMs and the set of end positions of all MMs are equal. The reason is that all right MM r have MM m with r as suffix from (R4) and Q (r) + | r | = Q (m) + | m | This is because it has the right MM as a suffix. Therefore, Tail [i, j] 702 corresponding to the end positions of all the MMs can be set to 1 by the above method (t1)-(t3).

  Consider the calculation time required to process this method (t1)-(t3). First, the processing time of (t1) is O (N) with respect to the sum N of input character string lengths. The processing time for (t2) is O (1). In (t3), processes other than (t3a) and (t3c) are O (N) as a whole because the number of nodes in T is O (N) and the processing time for each node is O (1). On the other hand, assuming that there are two different minimal right MMs with the same end position, the longer one is the suffix, so both contradict the assumption of the minimal right MM. Accordingly, there is only one minimal right MM having the same end position, and Tail [i, j] is not updated more than once for the same (i, j) in the process of (t3c). Since the number of elements in Tail is N, the processing time of (t3c) is also O (N).

 Indicates that the total processing time required for processing (t3a) is O (N). If v is not a leaf, v ′ (s) = suffixlink (v) can be identified by O (1), and therefore, O (N) for all non-leaf nodes. When v is a leaf, the process for identifying v ′ (s) from w ″ is O (1) for each leaf, and O (N) as a whole. Consider the processing time to identify w ″. The process of identifying leaf w '' from leaf v is performed once for each leaf v, but the total processing time is from the first suffix of the string Si $ for all 0 ≦ i <k | Less than the time to identify the leaf in order until the Si | th suffix. Therefore, the upper limit of the latter processing time is considered. Let x be a variable representing a node on suffix tree T. Then, consider the process of tracing from leaf v with the character string with $ added to the j j suffix to the leaf w '' with the character string with $ added to the j + 1 suffix . Assume that the value of x is sequentially updated to the node of interest. Hereinafter, the process of changing x from w ′ to w ″ is referred to as a downwalk. The processing time required to update x from v to w is O (1) because the parent node is always stored in the depth-first search process, and updating from w to w 'is also possible using suffixlink. O (1). Since the time to follow the path from w ′ to w ″ is O (1) every time one node passes, it is O (n) for the number n of nodes on this path. Describe that the processing time required for the downwalk is O (| Si |) when the sum of the entire processing for the character string Si is taken. The number of nodes (including the root node and x) on the path from the root node to x is defined as the node depth of x, and the increase or decrease is considered. The node depth of x increases by 1 every time one node is passed in the process of shifting from w ′ to w ″. On the other hand, when x is updated from leaf v to its parent node w, it decreases by one. Further, when x is updated to w ′, the maximum value of the decrease in node depth is 1. Because, in general, when nodes v1 and v2 are in the relationship of v2 = suffixlink (v1), it is | p (v1) | = | p (v2) | +1, and the path label length is equal on the path from the root node to w Since there are no nodes, any node other than the root node on the path from the root node to w has a suffix link to different nodes on the path from the root node to w ', so the node depth of w' is This is because (node depth of w) -1 or more. Therefore, in the process of sequentially tracing the leaves corresponding to the Si suffix, the node depth of x decreases by 2 × | Si | at maximum. On the other hand, since the maximum length of the suffix of a character string with $ added to the end of Si is | Si | +1, the node depth of the leaf corresponding to the suffix of Si $ is always less than or equal to | Si | +2. Therefore, if the sum of the number of times x is updated in all downwalks for Si is n, then n−3 × Si | ≦ | Si | +2 and n ≦ 3 | Si | + 2 = O (| Si | ). Therefore, it was found that the processing time required to follow the leaf corresponding to | Si | suffix is O (| Si |). From this, it is immediately understood that the processing time required to trace all the leaves is O (Σ | Si |) = O (N).

  The second method is to calculate the position of right MM r that does not have other right MM as a prefix, instead of directly calculating the position of MM in setting the value of Tail, and for any such r , (I, j) is an appearance of r, 1 is written to Tail [i, j + | r | -1] 702. The set of terminations of the right MM r (hereinafter referred to as “prefix minimum right MM”) that does not use other right MMs as prefixes is equal to the set of terminations of all MMs. Give the reason. First, from (R4), all right MM r have MM m with R as suffix from (R5) and Q (r) = Q (m) + | m |-| r |. Therefore, the following equation (1) holds, and the set of all the ends of the prefix minimum right MM is included in the set of ends of the MM.

  In Equation (1), pmrMM represents a set of “prefix minimum right MM”. On the other hand, any suffix s of m length u or more is right MM. Because s is a substring of m, it satisfies (R1), because it is longer than u, it satisfies (R2), and also satisfies (R3) by the following discussion. First, when m is a suffix of an input string, it is clear that s is a suffix of that string, and s satisfies (R3). When m is not a suffix of any string, there exists an appearance (i, j), (i ', j') for different characters a and b, respectively, and (i, j) ∈Q (m), Si [j + | m |] = a, (i ′, j ′) ∈Q (m), Si ′ [j ′ + | m |] = b. That is, m may appear with a on the right or b with b. Since s is a suffix starting with the m | m |-| s | th character of m, (i, j + | m |-| s |) ∈Q (s), Si [(j + | m |-| s |) + | s]] = Si [j + | m |] = a, (i ', j' + | m |-| s |) ∈Q (s), Si '[(j' + | m |-| s |) + | s]] = Si '[j' + | m |] = b. That is, since s can also appear with a on the right side and with b, it can satisfy (R3) because Q (s) ≠ Q (sa) for any character a∈Σ . In addition to the above, since MM m is a right MM of length u or more, m always has a suffix s of length u or more, and suffix r of length u is right from the above discussion. Although it is MM, the length of the prefix is less than u-1, so the right MM is not a true prefix. That is, r is the prefix minimum right MM, and all MMs have the prefix minimum MM in the suffix. Therefore, equation (2) holds. That is, the set of all the ends of the prefix minimum right MM includes the set of ends of the MM.

  From Equations (1) and (2), Equation (3) holds, and it can be seen that the set of the entire end of the prefix minimum right MM is equal to the set of the end of MM.

Based on the above, Tail [i, j] 702 corresponding to the ends of all right MMs can be set to 1 by the following method (t′1)-(t′3).
(t'1) All elements of 2D array Tail 701 are initialized to 0.
(t'2) The variable k is initialized with -1.
(t'3) Suffix depth tree T is searched for suffix tree T, and processing of (t'3a) and (t'3b) is performed for the node v encountered.
(t'3a) If v is marked as "right MM" and k <0, substitute | p '(v) | for k. k is returned to −1 when the depth-first exploration of the subtree containing v of v is over.
(t'3b) When v is a leaf and k> 0, Tail [i, j + k−1] 701 is set to 1 for an arbitrary appearance (i, j) associated with v.

  By this method, 1 is written to Tail [i, j + | r | -1] when and only when there is a prefix minimum right MM r ending with the j-th character of the input character string i. Conversely, Tail [i, j] is not 1 except for i, j. In depth-first exploration, the same leaf is not processed more than once, so this method does not update Tail [i, j] more than once for the same (i, j). Therefore, (t′1)-(t′3) can be completed with O (N).

  Note that instead of calculating only the position of the minimum right MM and prefix minimum right MM, Tail [i, j + | m | -1] = for all appearances (i, j) for all MM m In the method of 1, it may not be completed in the processing time of O (N). Assuming N is divisible by the number of strings k and N ≧ 3k (u + k), the string set {Si = T ^ (u + i) AT ^ (N / k- (u + i + 1)) } Consider (0 ≦ i <k) (FIG. 6). However, "a ^ n" represents n repetitions of the letter a. In this string set, a total of k-1 strings T ^ u, ..., T ^ (u + k-2) with T continuous between u and u + k-2 are represented by Si [ 0..u + i-1] = T ^ (u + i), Si [u + i] = A, S (i + 1) [0..u + i-1] = T ^ (u + i ), S (i + 1) [u + i] = T, which satisfies (R1)-(R3), so these are right MM. However, S (i + 1) represents the i + 1th input character string. Here, in Sj (0≤j <k), N ^ k- (u + j + 1) Ts are arranged after Sj [u + j] = A, so T ^ (u + i) is Sj N / k- (u + j + 1)-(u + i) + 1 = N / k-2u-ij times or more (N ≧ 3k (u + k), i ≦ k, j ≦ k , N / k-2u-ij ≧ k (u + k) ≧ 0). Therefore, the number of appearances of the MM in the entire string set under consideration is Ω (Nk) because (k-1) N / 3 or more from Equation (4). From the above, it can be seen that the method of enumerating the appearances of all MMs and searching for the end does not necessarily set the value of Tail in the processing time of O (N).

  Next, a method for setting Head [i, j] 701 will be described. First, in step S503, when extraction of the left MM is completed, in order to set Head [i, j], suffix tree T is suffix tree T 'and Tail [i, j] is Head [i, , | Si | -1-j] and apply the above method for setting tails. The fact that the two-dimensional array Head can be set correctly by this method is self-evident because the above method sets Tail correctly, and the processing can be completed in O (N) time.

  On the other hand, when step S504 is executed instead of step S503, a depth-first exploration of the suffix tree T is performed, and another node v is marked on the path from the root node to v with the node v marked “MM”. If a node v is found that does not have a node marked as “MM”, within the subtree of v, for any appearance (i, j) associated with any leaf encountered, Head [ i, j] 701 may be set to 1. With this method, since the Head [i, j] 701 is not updated more than once for the same appearance (i, j), it can be completed in the processing time of O (N). By the way, the position of MM m 'that has other MM m as a true prefix is not calculated by this method, but since m is a prefix of m' and Q (m) ⊇Q (m '), m' is the input character. If it is a substring starting with the jth character in sequence i, so is m, and Head [i, j] is correctly set to 1. In this way, it is clear that Head [i, j] does not become 1 when an arbitrary character string starting from the j-th character in the input character string i is not MM.

■ Extraction of right EG-holder (Step S506)
The node v whose p ′ (v) is the right EG-holder can be marked as “right EG-holder” by the method (h1)-(h3) described below. Set the value of the two-dimensional array Tv with (h1)-(h2), and mark “I am right EG-holder” with (h3).
(h1) Prepare a two-dimensional array Tv and initialize all elements of Tv with a null pointer. Note that, similarly to Head and Tail, Tv is also defined for the input character string i and a non-negative integer j that is smaller than the length of the character string. Furthermore, the variable shortest_right_MM is prepared and a null pointer is assigned.
(h2) Depth-first exploration of suffix tree T, and process (h2a) and (h2b) is performed for node v encountered.
(h2a) If node v is marked as “right MM” and shortest_right_MM is a null pointer, a pointer to v is assigned to shortest_right_MM. Note that the value of shortest_right_MM is returned to the null pointer at the stage when the processing of the subtree having v as the root node is completed.
(h2b) If the node v is a leaf, the value of the variable shortest_right_MM is assigned to Tv [i, j] for any appearance (i, j) associated with the leaf path label.
(h3) (i, j) (0 ≦ i <k, 0 ≦ j <| Si |) is the node indicated by Tv [i, j] when both of the following conditions (h3a) and (h3b) are satisfied Mark with “Right EG-holder”.
(h3a) Head [i, j] is 1 or j ≧ 1 and Tail [i, j-1] is 1.
(h3b) Tv [i, j] is not a null pointer.

This method (h1)-(h3) indicates that p '(v) is marked as "right EG-holder" only on those nodes v whose right EG-holder is p' (v) . First, by (h2), the value of Tv [i, j] is set to the following value.
(1) If there is one or more right MMs with appearances of (i, j), then let r be a right MM that has no other right MM in the prefix. Pointer.
(2) A null pointer if there is no right MM with appearance (i, j).

Based on this, it is shown that p ′ (v) is the right EG-holder for the node v marked as “right EG-holder” by the processing of (h1)-(h3).
About (H1):
Since only the node marked as “right MM” is marked as “right EG-holder”, p ′ (v) satisfies (H1).
About (H3):
If node v is marked as “right EG-holder” then Tv [i, j] = v ′ (p (v)) for appearance (i, j) with p ′ (v). Here, it is inconsistent with the definition of Tv [i, j], assuming that the true prefix of p '(v) and the existence of the character string r that is the right MM. Therefore, it can be seen that p ′ (v) satisfies (H3).
About (H2):
The method of the present invention can be applied only to a node indicated by Tv [i, j] where Head [i, j] is 1 or j ≧ 1 and Tail [i, j-1] is 1. Do not mark it as “-holder”. Therefore, for node v marked as "right EG-holder", p '(v) is the right MM that is the prefix of MM m with appearance (i, j) or the input string It is a right MM that starts with the next letter after a certain MM in Si. In the former case, r is MM from (R5). Therefore, (H2) is also satisfied.

  Next, assume that the right EG-holder is not marked on v ′ (h) for a certain right EG-holder h. First, it is assumed that a pointer to v ′ (h) does not enter Tv [i, j]. At this time, h is not a right MM, or there is a right MM that is a true prefix of h. From (H1) and (H3), it can be seen that h is the right EG-holder, contradicting that Tv [i, j] must contain a pointer to v '(h). The fact that h is still not marked as “right EG-holder” means that for any appearance (i, j) of h, Head [i, j] = 0 and Tail [i, j-1] = 0 (when j ≧ 1). At this time, for any MM m, (i, j) and (i, j- | m |) are not appearances of m, but such h satisfies (H2a) and (H2b). Again, it contradicts that h is the right EG-holder. Therefore, it is an error to assume that v ′ (h) is not marked as “right EG-holder”, and the method of the present invention does not oversuffice the node corresponding to the right EG-holder. You can see that it is marked "-holder".

■ EG extraction (step S507)
EG can be extracted without excess or deficiency by the following methods (e1)-(e3). The reason will be described later. The method of the present invention uses the values of Head, Tail, and Tv calculated in the previous steps in order to extract EG.
(e1) A variable EGlength (v) is provided for all nodes v in suffix tree T. Then, depth-first search is performed, and EGlength (v) = | p '(v) | is initialized.
(e2) The following processing (e2a)-(e2d) is performed for all input character strings Si.
(e2a) Variables c and j are initialized with c = 1, j = | Si | -1.
(e2b) If Tv [i, j] is not a null pointer, the value of the variable EGlength (v) for the node pointed to by Tv [i, j] is changed to the value 703 of c and EGlength (v) up to that point Replace with the smaller of the values.
(e2c) If Head [i, j] is 1, or if j ≧ 1 and Tail [i, j-1] is 1, substitute 1 for c, otherwise add 1 to c .
(e2d) Subtract 1 from the value of j. If j is greater than or equal to 0 after subtraction, the processing from (e2b) to (e2d) is performed again. If j is smaller than 0, the process for the input character string Si is completed.
(e3) A depth-first search is performed on Suffix tree T, and when node v satisfies both of the following conditions (e3a) and (e3b), v is marked as “EG”.
(e3a) v is marked as “right EG-holder”.
(e3b) EGlength (v) ≧ u

With the above method, it is explained that the prefix of the length EGlength (v) of the node v marked as “EG” is EG, and only those are EG. Prior to the explanation, it is shown that the conditions (E1)-(E5) are equivalent to the following conditions (E'1)-(E'5).
(E'1) Prefix of a right EG-holder.
(E'2) The length is not less than u.
(E'3) Does not overlap with MM, either right or left.
(E'4) MM is not a true substring.
(E'5) Not a true prefix of a string that satisfies (E'1)-(E'4).

In preparation for showing that the condition of (E1)-(E5) is equivalent to (E'1)-(E'5), the string e that satisfies (E'1) and (E'2) Indicates that the following (E'6) is satisfied.
(E'6) There is only one EG-holder h where e is a prefix and Q (e) = Q (h).

  In order to show that (E′6) holds, it is assumed that there are different right EG-holder h, h ′. Consider a character string s that is the longest character string in which es is a common prefix of h and h '. Since h and h 'are different from each other, at least one is longer than | es |. Without loss of generality, it can be assumed that | h |> | es |. Let h be the character after prefix es in h. Since es is the longest prefix common to h and h ', esa is not a prefix of h'. Therefore, Q (esa) ∩Q (h ′) = φ, but Q (esa) ≠ Q (es) because Q (es) ⊇Q (h ′) ≠ φ. On the other hand, for any character b other than a, Q (esb) ∩Q (h) = φ, but Q (esb) ≠ Q (es) because Q (es) ⊇Q (h) ≠ φ. Therefore, es satisfies (R3). From Q (es) ⊇Q (h) ≠ φ, es satisfies (R1), and | es | ≧ | e | ≧ u, so (R2) is satisfied. Therefore, es is the right MM. From | h |> | es |, | es | is a true prefix of | h |, which contradicts that h is a right EG-holder and satisfies (H3). Therefore, it is an error to assume the presence of different right EG-holders h, h ′, and the right EG-holder with e as a prefix is unique.

  On the other hand, e is a prefix of the right EG-holder h because it satisfies (E′1), and Q (e) ⊇Q (h). Here, assuming Q (e) ⊃Q (h), let a character string s be the longest character string Q (e) = Q (es) ⊃Q (h). At this time, es satisfies (R1) from Q (es) = Q (e) ≠ φ, satisfies (R2) from | es | ≧ | e | ≧ u, and satisfies (R3) from the definition of s. It is. From Q (es) ⊃Q (h), | es |> | h |, so es is a true prefix of h, but contradicts that h is a right EG-holder and satisfies (H3). Therefore, the assumption of Q (e) ⊃Q (h) is incorrect and Q (e) ⊆Q (h). Since e is a prefix of h, Q (e) = Q (h) from Q (e) ⊇ Q (h). This shows that (E’6) is correct.

First, a character string e that satisfies (E'1)-(E'5) satisfies (E1)-(E5).
Since string e satisfies (E'1)-(E'4), it is clear that (E1)-(E4) is also satisfied.

  (E5) is also satisfied. Assuming that e ′ = ses ′ ≠ e satisfies (E1)-(E4), a contradiction is introduced. From (E'6), e has a right EG-holder h with e as a prefix, and h is a right MM from (H1), so from (R4), Q (h) + | h | = There is a MM m with Q (m) + | m |, where h is a suffix.

  Here, assuming | es' |> | h |, there is ses' from Q (es') ⊆Q (e) = Q (h) = Q (m) + | m |-| h | On the input character string, as shown in FIG. 9, h exists as a prefix of es ′, and m has h as a suffix. Since | es ’|> | h |, e ′ = ses ′ overlaps with m on the left and contradicts (E3), or includes m as a true substring and contradicts (E4), resulting in a contradiction. Therefore, | es ′ | ≦ | h |, and Q (es ′) ⊆Q (e) = Q (h), es ′ is a prefix of h. Further, Q (es ′) = Q (h) from Q (e)) Q (es ′) ⊇Q (h) = Q (e).

  Next, assume that | s | ≧ 1. At this time, if h is MM, there is a substring sh on the input string Si from Q (e ') + | s | ⊆Q (es') = Q (h), so e '= ses' As shown in Fig. 10, if | es' | <| h |, it overlaps with MM h on the right, and if | es' | = | h | has h as a true substring, e 'is (E3 ) And (E4) are inconsistent, so h is not MM. However, since h satisfies (H2), it satisfies (H2b). Therefore, for a certain MM m ′, there is a character string m′h on a certain input character string. Here, let t be the longest character string satisfying Q (tes ′) + | t | = Q (es ′) = Q (h) (FIG. 11). Assuming | t | ≧ | s |, Q (tes ') + | t | ⊆Q (ses') + | s | ⊆Q (es ') = Q (h) = Q (tes') + | t As shown in FIG. 11, (i, j) εQ (m′h) + | m ′ | holds true for a certain (i, j) εQ (ses ′) + | s |. At this time, since es 'in e' = ses 'is a prefix of h in m'h, e' overlaps with m 'on the left and contradicts (E3) or includes m' as a true substring. Contradict with (E4). Therefore | t | <| s |. However, since t is the longest string satisfying Q (tes') + | t | = Q (es') = Q (h), for any (i, j) ∈Q (tes') + | t | (i, j- | t |) ∈Q (t) and (i, j) ∈Q (es') = Q (h) and Si [j- | t | .. j + | h | -1] = From (i, j) ∈Q (th) + | t | from Q, so Q (tes ') + | t | ⊆Q (th) + | t |, while Q (ates') for any a∈Σ + | t | + 1⊂Q (tes') + | t | ⊆Q (th) + | t | So t is also the longest string satisfying Q (th) + | t | = Q (h) . Therefore, th satisfies (M4) and is MM, but from | t | <| s |, e 'overlaps with th on the right and contradicts (E3) or contains th as a true substring (E4 ) (When | es' | = | h |). Eventually, if | s | ≧ 1, a contradiction occurs, so | s | = 0 and e ′ = es ′. From | es ′ |> | h | and Q (es ′) = Q (h), es ′ is a prefix of the right EG-holder h and satisfies (E′1). Furthermore, since it is assumed that e '= es' satisfies (E1)-(E4), (E'2)-(E'4) is also satisfied. However, since e ≠ e ′, s ′ ≠ ε, and e is a true prefix of e ′. This contradicts that e satisfies (E’5). In the end, it is an error to assume the existence of e ′ = ses ′ ≠ e that satisfies (E1)-(E4), and it can be seen that e satisfies (E5).

  Next, if the character string e satisfies (E1)-(E5), it indicates that (E′1)-(E′5) is satisfied. First, consider (E’1). Let s be the longest character string Q (es) = Q (e). Indicates that this es is an EG-holder. Since e satisfies (E1), Q (es) = Q (e) ≠ φ. Therefore, es satisfies (R1). From | es | ≧ | e | ≧ u, es satisfies (R2). By definition, s is the longest character string Q (e) = Q (es), so (es) satisfies (R3). Therefore, es is the right MM and satisfies (H1).

  Assume the existence of right MM r, the true prefix of es. Since r satisfies (R3), if the character following r, which is the prefix of es, is a, then Q (r) ⊃Q (ra) ⊇Q (es) = Q (e) and | r | <| e |. From (R4), there exists a certain MM m with r as suffix, and Q (m) + | m | = Q (r) + | r |. Therefore, e overlaps with m on the left and contradicts (E3) or includes m as a true substring and contradicts (E4) (Fig. 12). Thus, it is an error to assume that r exists, and es does not have the right MM as a true prefix. That is, es satisfies (H3).

In addition, we show that es satisfies (H2). Obviously (H2) is satisfied if es satisfies (H2b). Consider the case where es does not satisfy (H2b). Suppose es is not MM. If there is an input string with es as a prefix, es is MM, which is contrary to the assumption, so es is not a prefix of any input string. By the way, since es is the right MM, that es is not MM means that (M4) is not satisfied, and Q (aes) + 1 = Q (es) ≠ φ holds for a certain character a. At this time, ae satisfies (E1)-(E4) as shown below.
About (E1):
Since e satisfies (E′1), Q (aes) + 1 = Q (es) = Q (e) ≠ φ. Therefore, Q (ae) ⊇Q (aes) ≠ φ.
About (E2):
| ae | = | e | +1> u.
About (E3):
Suppose ae overlaps a certain MM. Since e satisfies (E3) and does not overlap with MM, ae either overlaps with MM with a as suffix on the left, or overlaps with MM with e as prefix on the right. Since es does not satisfy (H2b), there is no input string with mes as a substring for any MM m. From Q (es) = Q (e), there is no input string with me as a substring. Therefore, ae does not overlap with MM on the left. On the other hand, assuming the existence of MM m with e as a prefix, Q (es) = Q (e) contradicts that es satisfies (H3) if | m | <| es | If ≧ | es |, es is MM from (R5), but it contradicts that es is not MM. Therefore, in both cases, a contradiction occurs, so it can be seen that ae does not overlap with MM.
About (E4):
Assume the presence of MM m in the true substring of ae. Since e satisfies (E4), there is no MM in the true substring of e. Furthermore, if e is MM, if s = ε, it is inconsistent that es is not MM, and if s ≠ ε, it is inconsistent that there is no right MM in the true prefix of es. Therefore, m is the true prefix of ae. Assuming m = a, from Q (aes) + 1 = Q (es), es always appears in the input string with MM a on the left, which contradicts (H2b). Therefore, m ≠ a. However, if m, which is the true prefix of ae, is a string of two or more characters, e overlaps with m on the left and contradicts that e satisfies (E3). From the above, it can be seen that ae satisfies (E4) because a contradiction always occurs if the existence of m, which is the true substring of ae, is assumed.

  From the above, ae satisfies (E1)-(E4), but since ae contains e as a true substring, it contradicts that e satisfies (E5). Therefore, the assumption that es is not MM is incorrect. That is, since es satisfies (H2b) or (H2a), it satisfies (H2) and is the right EG-holder. Therefore, e satisfies (E′1).

  Furthermore, since es satisfies (E′2) and satisfies (E3) and (E4) from | es | ≧ | e | ≧ u, it satisfies (E′3) and (E′4). Assuming that e is a true prefix and there is a string e 'that satisfies (E'1)-(E'4), e' is (E1)-(E'1)-(E'4) E4) is satisfied, but this contradicts that e satisfies (E5). Therefore, it can be seen that such e 'does not exist and e satisfies (E'5).

  Thus, it has been shown that the conditions (E1)-(E5) are equivalent to the conditions (E′1)-(E′5). Therefore, in order to indicate that the character string satisfying the conditions (E1)-(E5), that is, the EG can be extracted without excess or deficiency, the character string satisfying the condition (E'1)-(E'5) And the set of prefix e with the length EGlength (v) of the path label p (v) of the node v marked as “EG” may be shown.

First, we show that e satisfies (E'1)-(E'5).
About (E'1):
Since EGlength (v) is initialized to the length of the character string excluding $ from p (v), the value does not increase, so the prefix of the length EGlength (v) of p (v) is $ Not included. Therefore, e satisfies (E'1).
About (E'2):
From the condition (e3b), for the node v marked as “EG”, since EGlength (v) ≧ u, e satisfies (E′2).
About (E'3), (E'4):
In step (e2b), the value 703 of the variable c (see FIG. 7) is a partial character string with appearance (i, j), and the beginning of any MM other than the jth character in the input character string i The length of the longest string that does not include the next character and the next character. On the other hand, for any appearance (i, j) of any right EG-holder h, if v = Tv [i, j], then v = v '(h) because h is the right EG-holder, and In step (e2b), EGlength (v) is updated to the smaller one of EGlength (v) and variable c value 703 at that time. The initial value of EGlength (v) is | p '(v) | = | h |. Therefore, when (e2) is completed, EGlength (v) becomes the maximum integer n that satisfies the following conditions (e4a) and (e4b).
(e4a) n ≦ | h |
(e4b) There is no character string that overlaps MM or has MM as a partial character string with a prefix of length n and h.
Therefore, the character string e satisfies (E'3) and (E'4).
About (E'5):
EGlength (v) is the length of the longest EG-holder prefix satisfying (E'3) and (E'4) with e as a prefix. Since the length of e is EGlength (v), (E'5) is also satisfied.

  Conversely, a character string other than the prefix of EGlength (v) of node v marked as “EG” by the method of the present invention indicates that it is not an EG.

  First, character strings other than the prefix of the right EG-holder are excluded, but such character strings do not satisfy (E′1). The condition (e3b) excludes character strings with a length less than u, but these do not satisfy (E′2). Furthermore, EGlength (v) is the length of the longest string that satisfies (E'3) and (E'4) with the prefix of p '(v) that is the right EG-holder, so EGlength with the prefix of the path label of v Character strings longer than (v) contradict (E'3) or (E'4). Furthermore, a character string shorter than EGlength (v) contradicts (E′5).

  From the above, it was found that the character string that is not determined to be EG by the method of the present invention is not EG.

(3) Processing time of the method of the present invention The behavior of the processing time of the method of the present invention with respect to the total number N of characters in the input character string will be examined. The processing of the present invention includes depth-first search for the suffix tree T, the number of times that does not depend on the number of input strings and the number of characters in the input string, constant time processing for each node in each depth-first search, and the total number of elements. The number of input strings for each element of the three two-dimensional arrays Head, Tail, Tv where N is N, and the number of constant times that do not depend on the number of characters in the input string, and the search for each leaf in (t3) O ( N) A combination of a fixed number of processes that can be completed in time. Therefore, the calculation time of the entire method of the present invention is O (N).

(1) Apparatus for realizing the method of the present invention The present invention also provides an apparatus for executing the method. FIG. 8 shows an example of the configuration of the apparatus. The apparatus stores a program 805 for executing the above method in the main memory 806, and further stores a suffix tree T and an input character string. The program 805 is executed by the central processing unit 801. The calculation result is displayed on the display 802, stored in the auxiliary storage device 807, or both of them are processed. Input from the user is performed using a keyboard 803 and a pointing device 804. The apparatus of the present invention may be communicably connected to another apparatus via a network such as the Internet or an intranet. The input character string is given in the form of a file, for example, and is taken into the main memory 806 by reading a file recorded on a recording medium such as a CD-R or a file received via a network. Of course, it is also possible to input an input character string from the keyboard. In this specification, means for taking an input character string into the main memory 806 of the apparatus is generically referred to as a character string input means.

  When displaying the EG obtained by the method of the present invention on the display 802, from the viewpoint of ease of viewing and analysis, the EG is represented as the input character string itself or the input character string as shown in the example of FIG. It is preferable to display the line segment or the rectangle 101 on the position 104 corresponding to the partial character string that is EG by a method that is easy to see visually, such as changing the color or displaying it with characters or symbols. Further, the position 102 on the input character string of the EG may be displayed regardless of whether or not the input character string is displayed with the line segment or the rectangle 101 symbolically indicating the input character string. Further, when displaying EGs derived from the same input character string, it is preferable that the start positions of the EGs are in ascending order. In ascending order, for each input string i, the variable j is increased from 0 to a value obtained by subtracting 1 from the length of the input string i, and Tv [i, j] is marked as "EG" This can be realized by displaying the EG whose length is EGlength (v) with the prefix of p (v) when it is a pointer to the connected node v. When storing the EG in the auxiliary storage device 807 together with the EG obtained from the same input character string, the same method as that used to obtain the display in ascending order of the start position by the above display method is used. It is preferable to obtain the ascending order of the start positions of EG and store them in that order.

  Further, when displaying the EG, it is preferable to display the EG so that the same EG existing in a plurality of input character strings can be identified using colors, symbols, character strings 103, and the like. Also, when recording in the auxiliary storage device 807, it is preferable to simultaneously record a number or a unique numerical value or character string for each EG so that a plurality of EGs can be identified as being the same.

■ Specification of exon boundaries by the user of the method of the present invention In the method of the present invention, exon boundaries are searched by mutual comparison of cDNA sequences. Exon boundaries that cannot be found by this method are known by some means. It may be. Therefore, it is desirable that the user of the method of the present invention can input the position of a known exon boundary so that the EG can be divided at the boundary. To do so, immediately after setting “Head and Tail” in step S505 when “a known exon boundary is between the j-th character and the j−1-th character of the input character string Si” is input. The following operations may be performed.
(b1) Set Head [i, j] to 1.
(b2) If j ≧ 1, set Tail [i, j-1] to 1.
When step S506 and subsequent steps are executed in this way, processing is performed in the same way as when there is an MM boundary between the jth character and the j-1th character of the input character string Si, and the EG is divided. . When there are a plurality of known exon boundaries, the processes (b1) to (b2) may be repeatedly executed for each boundary.

(1) Application of the method of the present invention to those other than cDNA sequences The present invention is intended for splicing pattern analysis of mRNA sequences, but can also be applied to comparative genome analysis. If the input character string is a genomic sequence instead of an mRNA sequence, and the obtained EG is interpreted as a conserved region in the genome, the position of the conserved region of the genomic sequence and conserved in multiple genomic sequences can be obtained by the method of the present invention. The correspondence of regions can be clarified, and it becomes an effective means of comparative genome analysis.

  In addition, if the types of characters used in the character string are limited, the method of the present invention can process a general character string without depending on the base sequence. The same can be applied to arrays and character strings.

  A system that implements the method of the present invention was created, and it was demonstrated that the splicing pattern of the base sequence can be analyzed by the method of the present invention. In the following, we describe the results when u is 15.

First, four base sequences s1, s2, s3, and s4 with a length of 30 characters were prepared using random numbers. These are combined to create four input strings s1s2s3, s1s2s4, s1s3s1, s2s3s4 of length 90, and these are combinations of s1, s2, s3, and s4 using software that implements the method of the present invention. I tried to recognize that. Note that s1 appears twice in the third string. The value of parameter u is 15. Note that s1, s2, s3, and s4 used here are the following arrays.
s1 = TTCAACAAAGACGGAAGTGTCCTAAATAGG
s2 = GTGCTGACAGTGCTGTTAGAACTACAGGCT
s3 = GAAGAAAGGTAACGCATATAGTGCGACGAA
s4 = GGTGGCATGCCATGGACGCATACTCCGTAA

  As a result of the treatment, four EGs shown in FIG. 1 were obtained. In this result, s1 and s4 were extracted as EG1 and EG4, but EG2 and EG3 were extracted as sequences lacking the first base each. This is because both s2 and s3 start with G, so the sequence with G added to the end of s1 and s2 becomes MM, and the sequence with one base deleted from s2, s3 becomes the right EG-holder. It is. In this way, EG may be shorter than the actual exon due to an accidental sequence match at the end. However, EG2 and EG3 almost coincided with s2 and s3, respectively, although they were not perfect matches. That is, by the method of the present invention, it can be said that the input character string can be recognized as a combination of four sequences having a length of about 30 bases. Furthermore, in the method of the present invention, it was also possible to recognize that s1 appears as two EG1s in the third array.

  Using the system in which the method of the present invention is implemented, the sequence of the human Wilms tumor gene WT1 among the splicing variant sequences of actual genes registered in the database RefSeq of the US public institution is obtained, analyzed, and obtained. The splicing patterns obtained were compared with the database description. The sequences used were three sequences with accession numbers NM_004906, NM_152857, and NM_152858. The database describes that the sequence from 576th base of NM_152857 and the 675th base of NM_152858 is a selective 3 ′ end sequence and that a selective 5 ′ end sequence exists in NM_152857. The result of applying the system in which the method of the present invention is implemented to these three arrays is as shown in FIG. The selective 3 ′ sequences of NM_152857 and NM_152858 described in the database were correctly recognized as EG5 including the start position. Furthermore, regarding the selective 5 ′ end sequence of NM_152857, there was no description of the position in the database, but the sequence from the top to the 115th base is the selective 5 ′ end sequence, and the 213th from the top of NM_004906 and NM_152858. It was found that the 5 'end sequence up to the base of was replaced. However, the selective 3 'sequence of NM_004906 was divided into 2 parts up to the 1566th base and 1592 base and later to become EG4 and EG6, and 25 bases between them became a blank section. All 25 bases in this blank section were T. From (M1)-(M4), all T sequences with a length of 15 bases or more are all MM, and EG was chosen so that these MMs are not true substrings. The cause was divided into EG4 and EG6. From this, it can be understood that when the method of the present invention is applied, it is necessary to pay attention to the repeat arrangement.

  In addition, although there was a blank section not included in EG at the end of all three sequences, these are polyA sequences and not exon sequences. In this section, A and 17 A or more continued, but 15 or more A continuation became MM, so the end of MM was dense at the poly-A sequence, and EG was not present.

  The total number of bases of the three input sequences used in this experiment was 5,529 bp, and the calculation time was about 0.1 seconds using a personal computer with a CPU clock frequency of 1.7 GHz.

The figure which shows the example which displayed the result analyzed by the method of this invention about four input arrangement | sequences which are the combination of four exons. The figure which shows the example which displayed the result of having extracted the exon sequence from the splicing variant of Wilms oncogene by the method of this invention. Illustration of input character string, right MM, MM, right EG-holder, EG. Illustration of Suffix tree. The flowchart of the whole process in the method of this invention. The figure which shows the example from which the sum total of the number of appearance of MM becomes (omega) (Nk). FIG. 5 is an explanatory diagram of the right EG-holder extraction in step S505 and the EG extraction method in step S506. Explanatory drawing of an example of the apparatus which implement | achieves the method of this invention. The figure explaining the relationship of the character string examined in order to guide | | es' | <| h | in description of the condition (E5) being derived | led-out from conditions (E'1)-(E'5). To explain that condition (E5) is derived from conditions (E'1)-(E'5), for a certain MM m ', to derive that a string m'h exists on a certain input string The figure explaining the relationship of the examined character string. In the explanation of the condition (E5) derived from the conditions (E'1)-(E'5), the relationship between the character strings examined to derive | t | <| s | To do. The figure explaining the relationship of the character string examined in order to derive | lead-out condition (E'1) from conditions (E1)-(E5). The figure explaining the definition that character strings s and s' overlap. The figure explaining the example where it is difficult to recognize that there are multiple exons based only on the sequence derived from the transcript. The figure explaining the example where it is difficult to identify the boundary of several exons based only on the sequence derived from a transcription product.

Explanation of symbols

101: Rectangle indicating the input string symbolically
102: A number representing the position of the EG on the input string
103: Example of character string to identify EG on multiple input character strings
104: Position on 101 corresponding to the substring that is EG
301: Input string example
302: List of right MM for 301 input string set
303: List of MM for 301 input string set
304: List of right EG-holder for 301 input string set
305: List of EGs for 301 input string sets
401: suffix tree constructed from string ATATG and TTAGTA
402: Root node of Suffix tree 401
403: One of the leaves of Suffix tree 401 (the leaf written as “i, j” corresponds to the suffix starting from j of string i)
404: One of the edges of Suffix tree 401
405: One of the labels on the edge of Suffix tree 401
407: One of the nodes in Suffix tree 401
408: Path from the root node 402 to a node in the Suffix tree 401
409: One of the suffix links in Suffix tree 401
701: Two-dimensional array Head extracted from input string 2
702: Extracted element of input string 2 from 2D array Tail
703: Value of variable c used in EG extraction method at step (e2b)
801: Central processing unit of the device of the present invention
802: Display of the device of the present invention
803: Keyboard of the device of the present invention
804: pointing device of the apparatus of the present invention
805: A program for executing the method of the present invention
806: Main memory of the device of the present invention
807: Auxiliary storage device of the device of the present invention

Claims (10)

When multiple character strings are input from the character string input means,
A partial character string that appears in one or more places in at least one of the input character strings, and whose length is greater than or equal to the given integer u, to the right or left of the substring A partial character string in which the set of positions in the input character string where a new character string obtained by adding one character appears is different from the set of positions where the partial character string appears before adding a character is When we call it MM
(1) A partial character string that appears in one or more places in at least one of the entered character strings,
(2) The length is not less than the integer u,
(3) The partial character string does not share a character on any input character string with any MM other than the MM that completely includes the partial character string,
A character string analysis method characterized by executing a process of extracting a character string called EG that is not part of another character string that satisfies only the above three conditions (1) to (3). 2. The character string analysis method according to claim 1, wherein the calculation unit includes:
A partial character string that appears in one or more places in at least one character string of the input character string, has a length greater than the given integer u, and adds one character to the right of the partial character string The set of positions in the input string where the new character string obtained in this way appears is a substring that is a different set from the set of positions where the substring appears before adding characters. A process of extracting a substring called MM,
A partial character string that appears in one or more places in at least one character string of the input character string, has a length that is greater than or equal to the integer u, and adds one character to the left of the partial character string Called left MM, where the set of positions in the input string where the resulting new string appears is a string that is different from the set of positions where the substring appears before the character is added A step of extracting a character string or a step of extracting a partial character string called MM,
The right EG-holder, which is a right MM starting from the next character of MM on the input character string and does not include the character string that is the right MM as a true prefix. The process of extracting the called string,
The character string analysis method characterized by performing. When multiple character strings are input from the character string input means,
A partial character string that appears in one or more places in at least one of the input character strings, and whose length is greater than or equal to the given integer u, to the right or left of the substring A partial character called MM in which the set of positions in the input character string where a new character string obtained by adding one character appears is different from the set of positions where the substring appears before the character is added A method of extracting a column,
The arithmetic unit is
A partial character string that appears in one or more places in at least one of the input character strings, has a length of the integer u or more, and adds one character to the right of the partial character string. A substring called the right MM, where the set of positions in the input string where the resulting new string appears is different from the set of positions where the substring appears before the character is added. A character string analysis method characterized by executing the extraction process. When multiple character strings are input from the character string input means,
A partial character string that appears in one or more places in at least one character string of the input character string, has a length greater than the given integer u, and adds one character to the right of the partial character string The set of positions in the input string where the new character string obtained in this way appears is a substring that is a different set from the set of positions where the substring appears before adding characters. A process of extracting a substring called MM,
A partial character string that appears in one or more places in at least one character string of the input character string, has a length that is greater than or equal to the integer u, and adds one character to the left of the partial character string A step of extracting a character string called left MM, which is a partial character string in which the set of positions where the obtained new character string appears is different from the set of positions where the partial character string appears before the character is added. Run,
A partial character string that appears in one or more places in at least one of the input character strings, has a length that is greater than or equal to the integer u, and adds one character to the right or left of the partial character string When a partial character string in which the set of positions in the input character string where the new character string obtained in this way appears differs from the set of positions where the partial character string appears before adding a character is called MM ,
The right EG-holder, which is a right MM starting from the next character of MM on the input character string and does not include the character string that is the right MM as a true prefix. A character string analysis method characterized by executing a process of extracting a called partial character string. When multiple character strings are input from the character string input means,
A partial character string that appears in one or more places in at least one character string of the input character string, has a length greater than the given integer u, and adds one character to the right of the partial character string When the set of positions in the input character string where the new character string obtained in this way is different from the set of positions where the partial character string appears before the character is added, the partial character string is Called MM,
A partial character string that appears in one or more places in at least one of the input character strings, has a length that is greater than or equal to the integer u, and adds one character to the right or left of the partial character string When the set of positions in the input character string where the new character string obtained as described above appears is different from the set of positions where the partial character string appears before the character is added, the partial character string is When calling
In the arithmetic unit,
The right EG-holder, which is a right MM starting from the next character of MM on the input character string and does not include the character string that is the right MM as a true prefix. A character string analysis method for executing a process of extracting a called partial character string,
In order to calculate the position of the MM in the input character string, it is a right MM that does not make the other right MM a true suffix. String analysis method to be performed. When multiple character strings are input from the character string input means,
A partial character string that appears in one or more places in at least one character string of the input character string, has a length greater than the given integer u, and adds one character to the right of the partial character string When the set of positions in the input character string where the new character string obtained in this way is different from the set of positions where the partial character string appears before the character is added, the partial character string is Called MM,
A partial character string that appears in one or more places in at least one of the input character strings, has a length that is greater than or equal to the integer u, and adds one character to the right or left of the partial character string When the set of positions in the input character string where the new character string obtained as described above appears is different from the set of positions where the partial character string appears before the character is added, the partial character string is When calling
In the arithmetic unit,
The right EG-holder, which is a right MM starting from the next character of MM on the input character string and does not include the character string that is the right MM as a true prefix. A character string analysis method for executing a process of extracting a called partial character string,
In order to calculate the position of the MM in the input character string, the processing is performed to calculate the position of the character string called the prefix minimum right MM, which is a right MM that does not make the other right MM a true prefix. String analysis method. The character string analysis method according to claim 1,
A partial character string that appears in one or more places in at least one character string of the input character string, has a length greater than the given integer u, and adds one character to the right of the partial character string If the set of positions in the input character string where the new character string obtained in this way appears is different from the set of positions where the substring appears before the character is added, the substring is the right MM. When calling
The computing unit is
The right EG-holder that is the right MM starting from the next character of the MM on the input character string and does not include the character string that is the right MM as a true prefix. Character string analysis method characterized in that only the prefix of is used as a candidate for the substring EG to be extracted.   6. The character string analysis method according to claim 5, wherein when checking whether a right MM has another right MM that is a true suffix of the right MM, the right MM is displayed as a path label on the suffix tree. A character string analysis method that refers to the suffix link of the parent node of the node to be prefixed.   2. The character string analyzing method according to claim 1, wherein when a position to be a boundary of the EG is given on the input character string, the EG is divided so that the EG does not include the position. Column analysis method.   The program for making a computer perform the character string analysis method of any one of Claims 1-9.

Images