Computational pangenomics [26] ponders around the problem of expressing a reference genome of a species in a more meaningful way than as a string of symbols. The basic problem in such generalized representations is that one should still be able to support string matching type of operations on the content. Another problem is that any representation generalizing set of sequences also expresses sequences that may not be part of the real pangenome. That is, a good representation should have a feature to control over-expressiveness and simultaneously support efficient queries.
In this paper, we develop the theory around one promising pangenome representation candidate, the founder block graph. This graph is a natural derivative of segmentation algorithms [28, 13] related to founder sequences [34] .
Consider a set of individuals represented as lists of variations from a common reference genome. Such a set can be expressed as a variation graph or as a multiple sequence alignment. The former expresses reference as a backbone of an automaton, and adds a subpath for each variant. The latter inputs all variations of an individual to the reference, creating a row for each individual into a multiple alignment. Figure 1 shows an example of both structures with 6 very short genomes.
A multiple alignment of much fewer founder sequences can be used to approximate the input represented as a multiple alignment as well as possible, meaning that each original row can be mapped to the founder multiple alignment with a minimum amount of row changes (discontinuities). Finding an optimal set of founders is NP-hard [29] , but one can solve relaxed problem statements in linear time [28, 13] , which are sufficient for our purposes. As an example on the usefulness of founders, Norri et al. [28] showed that, on a large public dataset of haplotypes of human genome, the solution was able to replace 5009 haplotypes with only 130 founders so that the average distance between row jumps was over 9000 base pairs [28] . This means that alignments of short reads (e.g. 100 bp) very rarely hit a discontinuity, and the space requirement drops from terabytes to just tens of gigabytes. Figure 1 shows such a solution on our toy example.
A block graph is a labelled directed acyclic graph consisting of consecutive blocks, where a block represents a set of sequences of the same length as parallel (unconnected) nodes. There are edges only from nodes of one block to the nodes of the next block. A founder block graph is a block graph with blocks representing the segments of founder sequences corresponding to the optimal segmentation [28] . Fig. 1 visualises such a founder block graph: There the founder set is divided into 3 blocks with the first, the second, and the third containing sequences of length 4, 4, and 3, respectively. The coloured connections between sequences in consecutive blocks define the edges. Such graphs interpreted as automata recognise the input sequences just like variation graphs, but otherwise recognise a much smaller subset of the language. With different optimisation criteria to compute the founder blocks, one can control the expressiveness of this pangenome representation.
In this paper, we show that there is a natural subclass of founder block graphs that admit efficient index structures to be built that support exact string matching on the paths of such graphs. Moreover, we give a linear time algorithm to construct such founder block graphs from a given multiple alignment. The construction algorithm can also be adjusted to produce a subclass of elastic degeneralized strings [9] , which also support efficient indexing.
The founder block graph definition given above only makes sense if we assume that our input multiple alignment is gapless, meaning that the alignment is simply produced by putting strings of equal length under each other, like in Figure 1 . We develop the theory around founder block graphs under gapless multiple alignments. However, most of the results can be easily extended to handle gaps properly.
We start in Sect. 2 by putting the work into the context of related work. In Sect. 3 we introduce the basic notions and tools. In Sect. 4 we study the property of founder block graphs that enable indexing. In Sect. 5 we give the linear time construction algorithm. In Sect. 6 we develop a succinct index structure that supports exact string matching in linear time. In Sect. 7 we consider the general case of having gap symbols in multiple alignment. We report some preliminary experiments in Sect. 8 on the construction and indexing of founder block graphs for a collection of SARS-CoV-2 strains. We consider future directions in Sect. 9.
Indexing directed acyclic graphs (DAGs) for exact string matching on its paths was first studied by Sirén et al. in WABI 2011 [32] . A generalization of Burrows-Wheeler transform [12] was proposed that supported near-linear time queries. However, the proposed transformation can grow exponential size in the worst case. Many practical solutions have been proposed since then, that either limit the search to short queries or use more time on queries [33, 22, 24, 31, 19] .
More recently, such approaches have been captured by the theory on Wheeler graphs [18, 20, 2] .
Since it is NP-hard to recognize if a given graph is Wheeler [20] , it is of interest to look for other graph classes that could provide some indexability functionality. Unfortunately, quite simple graphs turn out to be hard to index [15, 16] (under the Strong Exponential Time Hypothesis). In fact, the reductions by Equi et al. [15, 16] can be adjusted to show that block graphs cannot be indexed in polynomial time to support fast string matching. But as we will later see, further restrictions on block graphs change the situation.
Block graphs have also tight connection to generalized degenerate (GD) strings and their elastic version. These can also be seen as DAGs with a very specific structure. Matching a GD string is computationally easier and even linear time online algorithms can be achieved to compare two such strings, as analyzed by Alzamel et al. [3] . The elastic counterpart requires more care, as studied by Bernardini et al. [9] . Our results on founder block graphs can be casted on GD strings and elastic strings, as we will show later.
Finally, our indexing solution has connections to succinct representations of de Bruijn graphs [11, 10, 8] . Compared to de Bruijn graphs that are cyclic and have limited memory (k-mer length), our solution retains the linear structure of the block graph.
Definitions and basic tools
We 
As mentioned in the introduction, our goal is to compactly represent a gapless multiple sequence alignment (MSA) using a founder block graph. In this section we formalize these concepts.
A gapless multiple sequence alignment MSA[1..m, 1..n] is a set of m strings drawn from Σ, each of length n. Intuitively, it can be thought of as a matrix in which each row is one of the m strings. Such a structure can be partitioned into what we call a segmentation, that is, a collection of sets of shorter strings that can represent the original alignment. 
A segmentation of a MSA can naturally lead to the construction of a founder block graph. Let us first introduce the definition of a block graph.
A block graph is a graph G = (V, E, ) where : V → Σ + is a function that assigns a string label to every node and for which the following properties hold.
As a convention we call every V i a block and every (v) a segment.
Given a segmentation S of a MSA, we can define the founder block graph as a block graph induced by S. The idea is to have a graph in which the nodes represents the strings in S while the edges retain the information of how such strings can be recombined to spell any sequence in the original MSA. We regard the edges of (founder) block graphs to be directed from left to right. Consider a path P in G(S) between any two nodes. The label (P ) of P is the concatenation of labels of the nodes in the path. Let Q be a query string. We say that Q occurs in G(S) if Q is a substring of (P ) for any path P of G(S). Figure 2 illustrates such queries.
In our example in Figure 1 , segmentation S would be [1.
.4], [5. .8], [9..11] , and the induced founder block graph has thus 3 blocks with 9 nodes and 11 edges in total.
A trie [14] of a set of strings is a rooted directed tree with outgoing edges of each node labeled by distinct characters such that there is a root to leaf path spelling each string in the set; shared part of the root to leaf paths to two different leaves spell the common prefix of the corresponding strings. Such a trie can be computed in O(N log σ) time, where N is the total length of the strings, and it supports string queries that require O(q log σ) time, where q is the length of the queried string.
An Aho-Corasick automaton [1] is a trie of a set of strings with additional pointers (fail-links). While scanning a query string, these pointers (and some shortcut links on them) allow to identify all the positions in the query at which a match for any of the strings occurs. Construction of the automaton takes the same time as that of the trie. Queries take O(q log σ + occ) time, where occ is the number of matches.
A suffix array [25] A bidirectional BWT index [30, 7] is a succinct index structure based on some auxiliary data structures on BWT. Given a string T ∈ Σ n , with σ ≤ n, such index occupying O(n log σ) bits of space can be build in O(n) time and it supports finding in O(q) time if a query string Q [1. .q] appears as substring of T [7] . Moreover, such query returns an interval pair 
We now show that there exist a family of founder block graphs that admit a polynomial time constructable index structure supporting fast string matching. First, a trivial observation: the input multiple alignment is a founder block graph for the segmentation consisting of only one segment. Such founder block graph (set of sequences) can be indexed in linear time to support linear time string matching [7] . Now, the question is, are there other segmentations that allow the resulting founder block graph to be indexed in polynomial time? We show that this is the case.
Our example graph ( Fig. 1) is not quite segment repeat-free, as TAT occurs also as substring of paths starting with ATAT.
To prove the proposition, we construct such an index and show how queries can be answered efficiently.
Let P (v) be the set of all paths starting from node v and ending in a sink node. Let
Then one can binary search any query string Q in P to find out if it occurs in G(S) or not. The problem with this approach is that P is of exponential size.
However, if we know that G(S) is segment repeat-free, we know that the lexicographic order of (L)
where w is the node following v on the path L. Let P (v, i) denote the set of suffix path labels cut at this manner. Now the corresponding set P = ∪ v∈V,1≤i≤| (v)| P (v, i) is no longer of exponential size. Consider again binary searching a string Q on sorted P . If Q occurs in P then it occurs in G(S). If not, Q has to have some (v) for v ∈ V as its substring in order to occur in G(S).
To figure out if Q contains (v) for some v ∈ V as its substring, we build an Aho-Corasick automaton [1] 
To verify such potential match, we need several tries [14] . For each v ∈ V , we build tries
to the leaf we reached in the trie. If the search succeeds after reading Q [1] we have found a path in G(S) spelling Q [1..j] . We repeat the analogous procedure with Q[j..m] starting from trie F(v). That is, we can verify a candidate occurrence of Q in G(S) in O(|Q| log σ) time, as the search in the tries takes O(log σ) time per step. Note however, that there could be several labels (v) occurring as substrings of Q, so we need to do the verification process for each one of them separately. There can be at most |Q| such candidate occurrences, due to the distinctness of node labels in G(S). In total, this search can take at most O(|Q| 2 log σ) time.
We are now ready to specify a theorem that reformulates Proposition 5 in detailed form.
Theorem 6. Let G = (V, E) be a segment repeat-free founder block graph with blocks To avoid the costly binary search in sorted P , we instead construct the bidirectional BWT index [7] for the concatenation C = i∈{1,2,...,b} v∈V i ,(v,w)∈E (v) (w)0. Concatenation C is thus a string of length O(|E|W ) from alphabet {0, 1, 2, . . . , σ}. The bidirectional BWT index for C can be constructed in O(|C|) time, so that in O(|Q|) time, one can find out if Q occurs in C [7] . This query equals that of binary search in P .
We remark that founder block graphs have a connection with generalized degenerate strings (GD strings) [4] . In a GD string, sets of strings of equal length are placed one after the other to represent in a compact way a bigger set of strings. Such set contains all possible concatenations of those strings, which are obtained by scanning the individual sets from left to right and selecting one string from each set. The length of the strings in a specific set is called width, and sum of all the width of all sets in a GD string is the total width. Given two GD strings of the same total width it is possible to determine if the intersection of the sets of strings that they represent is non empty in linear time in the size of the GD strings [4] . Thus, the special case in which one of the two GD string is just a standard string can be seen also as a special case of a founder block graph in which every segment is fully connected with the next one and the length of the query string is equal to the maximal length of a path in the graph.
We consider the question of indexing GD strings (fully connected block graphs) to search for queries Q shorter than the total width. We can exploit the segment repeat-free property to yield such an index. Theorem 7. Let G = (V, E) be a segment repeat-free GD string a.k.a. a fully connected segment repeat-free founder block graph with blocks Proof. Recall the index structure of Theorem 6. for the case of GD strings, we can simplify it as follow.
We keep the same BWT index structure and the Aho-Corasick automaton, but we do not need any tries. After finding at most |Q| occurrences of substrings of Q in the graph using the Aho-Corasick automaton on node labels, we mark the matching blocks accordingly. If 2 marked blocks have exactly one marked neighboring block and |Q| − 2 blocks have 2 marked neighboring blocks, then we have found an occurrence, otherwise not.
Observe that max(N, W |E|) ≤ mn, where m and n are the number of rows and number of columns, respectively, in the multiple sequence alignment from where the founder block graph is induced. That is, the index construction algorithms of the above theorems can be seen to be almost linear time in the (original) input size. We study succinct variants of these indexes in Sect. 6, and also improve the construction and query times to linear as side product.
We can adapt the dynamic programming segmentation algorithms for founders [28, 13] to produce segment repeat-free founder block graphs. The idea is as follows. Let S be a segmentation of MSA[1..m, 1..n]. We say S is valid if it induces a segment repeat-free founder block graph G(S) = (V, E). We build such valid S for prefixes of MSA from left to right, minimizing the maximum block length needed.
Proof. To see that this is a necessary condition for the validity of S, notice that each row of MSA can be read through G, so if (v) occurs elsewhere than inside the block, then these extra occurrences make S invalid. To see that this is a sufficient condition for the validity of S, we observe the following: a) For all (v, w) ∈ E, (v) (w) is a substring of some row of the input MSA. b) Let (x, u), (u, y) ∈ E be two edges such that U = (x) (u) (y) is not a substring of any row of input MSA. Then any substring of U either occurs in some row of the input MSA or it includes (u) as its substring. c) If (v ) for some v ∈ V does not occur as substring of some input MSA row, but it occurs as a substring of some path in G, then it includes (u) as its substring for some u ∈ V , where | (u)| < | (v )|. Such (u) occurs at least once outside the block V i , where u ∈ V i . That is, if (v ) makes S invalid then also (u) makes it invalid. d) Continuing case c) inductively, at some point there has to be (u ) for some u ∈ V such that (u ) is substring of (v) (w) for some (v, w) ∈ E. By a), such (u ) is also a substring of some row of the input MSA. That is, v of case c) cannot exist.
Let s(j ) be the score of an optimal (minimum scoring) valid segmentation S of prefix 
where s(j) . For the former, one can start comparing max(j − j , s(j )) from j = v(j) decreasing j by one, and then the value j − j grows bigger than s(j ) at latest after s(j) − (j − v(j)) ≤ s(j) steps. For preprocessing, we build the bidirectional BWT index of the MSA in O(mn) time [7] . At column j, consider the trie containing the reverse of the rows of M [1..m, 1..j]. Search the trie paths from the bidirectional BWT index until the number of leaves in each trie subtree equals the length of the corresponding BWT interval. Let j be the column closest to j where this holds for all trie paths. Then one can set v(j) = j . The O(m(j − v(j) ) log σ) time construction of the trie has to be repeated for each column. As j − v(j) ≤ s(j), the claimed preprocessing time follows.
We can do the preprocessing in O(mn) time. Proof. Let us build the bidirectional BWT index [7] of MSA rows concatenated into one long string. We will run several algorithms in synchronization over this BWT index, but we explain them first as if they would be run independently. Finally, the running time is O(mn), since each extend-left and contract-right operations take constant time [5] , and since the bitvectors are manipulated locally only on indexes that are maintained as variables during the execution.
Recall Eq. (1). Before proceeding to the involved optimal solution, we give some insights by first improving the running time to logarithmic per entry.
As it holds v(1) ≤ v(2) ≤ · · · ≤ v(n), the range where the minimum is taken grows as j grows. Now, [j ..j +s(j )] can be seen as the effect range of s(j ): for columns j > j +s(j ) the maximum from the options is j − j . Consider maintaining (key, value) pairs (s(j ) + j , s(j )) in a binary search tree (BST). When computing s(j) we should have pairs (s(j ) + j , s(j )) for [17] . Alternatively, we can remove elements from the BST once they no longer can be answers to queries, and we can get O(n log s max ) solution. To obtain better running time, we need to exploit more structural properties of the recurrence.
Cazaux et al. [13] considered a similar recurrence and gave a linear time solution for it. In what follows we modify that technique to work with valid ranges.
For j between 1 and n, we define
Lemma 10. For any j ∈ [1..n − 1], we have x(j) ≤ x(j + 1).
Proof. By the definition of x(.), for any j ∈ [1.
.n], we have for j ∈ [1..x(j) − 1], max(j − j , s(j )) ≥ max(j − x(j), s(x(j))) and for j ∈ [x(j) + 1..v(j)], max(j − j , s(j )) > max(j − x(j), s(x(j))). We assume that there exists j ∈ [1..n − 1], such that x(j + 1) < x(j). In this case, x(j + 1) ∈ [1..x(j) − 1] and we have max(j − x(j + 1), s(x(j + 1))) ≥ max(j − x(j), s(x(j))).
As v(j + 1) ≥ v(j), x(j) ∈ [x(j + 1) + 1..v(j + 1)] and thus max(j + 1 − x(j + 1), s(x(j + 1))) < max(j + 1 − x(j), s(x(j))). As x(j + 1) < x(j), we have j − x(j + 1) > j − x(j). To simplify the proof, we take A = j − x(j + 1), B = s(x(j + 1)), C = j − x(j) and D = s(x(j)). Hence Proof. We are going to show by induction. The base case is obvious because s(1) = K ≤ max(1, K). As s(j) = min j :1≤j ≤v(j) max(j − j , s(j )), by using induction, s(j) ≤ min j :1≤j ≤v(j) max(j, K) ≤ max(j, K) By using K = n + 1, we can have that each s(j) is in O(n).
Proof. We need just to compare k = max(j − j , s(j )) and s(j ) where j is in Argmin j ∈[j +1..v(j)] s(j ). If k is smaller than s(j ), k is smaller than all the s(j ) with j ∈ [j + 1..v(j)] and thus for all max(j − j , s(j )). Hence we have .n], we check any j from x(j − 1) to v(j) with the equality of Lemma 12 until one is true. With the property of the equality, we know that this j is x(j). After that we compute s(j) which corresponds to the value max(j − x(j), s(x(j))), we add s(j) to the constant time semi-dynamic range maximum query and we compute s(j + 1).
Recall the indexing solutions of Sect. 4 and the definitions from Sect. 3. We now show that explicit tries and Aho-Corasick automaton can be replaced by some auxiliary data structures associated with the Burrows-Wheeler transformation of the concat-
Consider interval SA[i..k] in the suffix array of C corresponding to suffixes having (v) as prefix for some v ∈ V . From the segment repeat-free property it follows that this interval can be split into two subintervals, SA[i. We are now ready to present the search algorithm that uses only the BWT of C and some small auxiliary data structures. We associate two bitvectors B and E to the BWT of = select(B, rank(B, j ) ) and k = select (E, rank(B, j ) ). If i ≤ j and k ≤ k, index j lies inside an interval SA[i..k] where all suffixes start with (v) for some v. We modify the range into SA[i..k], and continue with the backward step on Q[q − 1]. We check the same condition in each step and expand the interval if the condition is met. Let us call this procedure expanded backward search.
We can now strictly improve Theorems 6 and 7 as follows.
Let G = (V, E) be a segment repeat-free founder block graph (or a segment repeat-free GD string) with blocks Proof. (sketch) As we expand the search interval in BWT, it is evident that we still find all occurrences for short patterns that span at most two nodes, like in the proof of Theorem 6. We need to show that a) the expansions do not yield spurious occurrences for such short patterns and b) the expansions yield exactly the occurrences for long patterns that we earlier found with the Aho-Corasick and tries approach.
In case b), notice that after an expansion step we are indeed in an interval SA[i.
.k] where all suffixes match (v) and thus corresponds to a node v ∈ V . The suffix of the query processed before reaching interval SA[i..k] must be at least of length | (v)|. That is, to mimic Aho-Corasick approach, we should continue with the trie R(v). This is identical to taking backward step from BWT[i..k], and continuing therein to follow the rest of this implicit trie.
To conclude case b), we still need to show that we reach all the same nodes as when using Aho-Corasick, and that the search to other direction with L(v) can be avoided. These follow from case a), as we see.
In case a), before doing the first expansion, the search is identical to the original algorithm in the proof of Theorem 6. After the expansion, all matches to be found are those of case b). That is, no spurious matches are reported. Finally, no search interval can include two distinct node labels, so the search reaches the only relevant node label, where the Aho-Corasick and trie search simulation takes place. We reach all such nodes that can yield a full match for the query.
We have so far assumed that our input is a gapless multiple alignment. Let us now consider how to extend the results to the general case. The idea is that gaps are only used in the segmentation algorithm to define the valid ranges, and that is the only place where special attention needs to be taken; elsewhere, whenever a substring from MSA rows is read, gaps are treated as empty strings. That is, A-GC-TA-becomes AGCTA. It turns out that allowing gaps in MSA indeed makes the computation of valid ranges more difficult. To see this, consider a segment in MSA containing strings: Pattern location times in milliseconds by index size Figure 3 Running time of querying patterns from the founder block graph. The sample sizes (for MSA row subsets) are shown on the right-hand side of each plot. The plots show averages and distribution over 10 repeats of each search, where one search consist of a set of query patterns of given length randomly sampled from the respective MSA row subset. The pattern set sample size (10, 20, 30, 40 , respectively) grows by the MSA sample size, but the reported numbers are normalized so that the query time (milliseconds) is per pattern. This experiment was run on Intel(R) Core(TM) i5-4308U CPU, 2.80GHz. postprocessed using matching statistics [6] on all pairs of prefixes preceding suffixes causing nested intervals). Initial experiments show very similar behaviour to the gapless case, but we defer further experiments until the implementation is mature enough.
We implemented the succinct indexing approach of Sect. 6. On the founder block graph of the previous experiment, the index occupied 87 KB. This is 3% of the original input size, as the encoding of the input MSA with 2 bits per nucleotide takes 2984 KB. Figure 3 shows an experiment with indexes built on different size samples of the MSA rows, and with querying patterns of varying length sampled from the same rows. As can be seen, the query times are not affected by the size of the MSA samples (showing independence of the input MSA), but only on their length (showing linear dependency on the query length).
One characterization of our solution is that we compact those vertical repeats in MSA that are not horizontal repeats. This can be seen as positional extension of variable order de Bruijn graphs. Also, our solution is parameter-free unlike de Bruijn approaches that always need some threshold k, even in the variable order case. The founder block graph concept could also be generalized so that it is not directly induced from a segmentation. One could consider cyclic graphs having the same segment repeat-free property. This could be interesting direction in defining parameter-free de Bruijn graphs.
Future work include a proper extension of the approach to general MSA's containing gaps. Our implementation already contains support for such MSA's, but the theory framework still requires some more work to show that such extension can be done without any effect on the running time.
On the experimental side, there is still much more work to be done. So far, we have not optimized any of the algorithms for multithreading nor for space usage. For example, one could use BWT indexes engineered for highly repetitive text collections to build the founder block graphs in space proportional of the compressed MSA. Such optimizations are essential for applying the approach on e.g. human genome data. Past experience on similar solutions [28] indicate that our approach should easily be applicable to much larger datasets than those we covered in our preliminary experiments.
Finally, this paper only scratches the surface of a new family of pangenome representations. There are myriad of options how to optimize among the valid segmentations [28, 13] , e.g. by optimizing the number of founder segments [28] or controlling the over-expressiveness of the graph, rather than minimizing the maximum block size as studied here.