The evolutionary history of a set of taxa is usually represented by a phylogenetic tree, and this model has greatly facilitated the discussion and testing of hypotheses. However, it is well known that more complex evolutionary scenarios are poorly described by such models. Further, even when evolution proceeds in a tree-like manner, analysis of the data may not be best served by using methods that enforce a tree structure but rather by a richer visualization of the data to evaluate its properties, at least as an essential first step. Thus, phylogenetic networks should be employed when reticulate events such as hybridization, horizontal gene transfer, recombination, or gene duplication and loss are believed to be involved, and, even in the absence of such events, phylogenetic networks have a useful role to play. This article reviews the terminology used for phylogenetic networks and covers both split networks and reticulate networks, how they are defined, and how they can be interpreted. Additionally, the article outlines the beginnings of a comprehensive statistical framework for applying split network methods. We show how split networks can represent confidence sets of trees and introduce a conservative statistical test for whether the conflicting signal in a network is treelike. Finally, this article describes a new program, SplitsTree4, an interactive and comprehensive tool for inferring different types of phylogenetic networks from sequences, distances, and trees.

https://bioinformatics.cs.vt.edu/~easychair/HusonBryant_MBE_2006.pdf

Application of Phylogenetic Networks in Evolutionary Studies

BOLD: The Barcode of Life Data System: Barcoding

KEGG(Kyoto Encyclopedia of Genes and Genomes)〔和文〕 (特集 ゲノム医学の現在と未来--基礎と臨床) -- (データベース)

Gene families are growing rapidly, but standard methods for inferring phylogenies do not scale to alignments with over 10,000 sequences. We present FastTree, a method for constructing large phylogenies and for estimating their reliability. Instead of storing a distance matrix, FastTree stores sequence profiles of internal nodes in the tree. FastTree uses these profiles to implement Neighbor-Joining and uses heuristics to quickly identify candidate joins. FastTree then uses nearest neighbor interchanges to reduce the length of the tree. For an alignment with N sequences, L sites, and a different characters, a distance matrix requires O(N2) space and O(N2L) time, but FastTree requires just O(NLa + N) memory and O(Nlog (N)La) time. To estimate the tree's reliability, FastTree uses local bootstrapping, which gives another 100-fold speedup over a distance matrix. For example, FastTree computed a tree and support values for 158,022 distinct 16S ribosomal RNAs in 17 h and 2.4 GB of memory. Just computing pairwise Jukes–Cantor distances and storing them, without inferring a tree or bootstrapping, would require 17 h and 50 GB of memory. In simulations, FastTree was slightly more accurate than Neighbor-Joining, BIONJ, or FastME; on genuine alignments, FastTree's topologies had higher likelihoods. FastTree is available at http://microbesonline.org/fasttree.

/pdf/fasttree-computing-large-minimum-evolution-trees-with-eo2tre5l8r.pdf

FastTree: Computing Large Minimum Evolution Trees with Profiles instead of a Distance Matrix

Gene families are growing rapidly, but standard methods for inferring phylogenies do not scale to alignments with over 10,000 sequences. We present FastTree, a method for constructing large phylogenies and for estimating their reliability. Instead of storing a distance matrix, FastTree stores sequence profiles of internal nodes in the tree. FastTree uses these profiles to implement neighbor-joining and uses heuristics to quickly identify candidate joins. FastTree then uses nearest-neighbor interchanges to reduce the length of the tree. For an alignment with N sequences, L sites, and a different characters, a distance matrix requires O(N^2) space and O(N^2 L) time, but FastTree requires just O( NLa + N sqrt(N) ) memory and O( N sqrt(N) log(N) L a ) time. To estimate the tree's reliability, FastTree uses local bootstrapping, which gives another 100-fold speedup over a distance matrix. For example, FastTree computed a tree and support values for 158,022 distinct 16S ribosomal RNAs in 17 hours and 2.4 gigabytes of memory. Just computing pairwise Jukes-Cantor distances and storing them, without inferring a tree or bootstrapping, would require 17 hours and 50 gigabytes of memory. In simulations, FastTree was slightly more accurate than neighbor joining, BIONJ, or FastME; on genuine alignments, FastTree's topologies had higher likelihoods. FastTree is available at http://microbesonline.org/fasttree.

/pdf/fast-tree-computing-large-minimum-evolution-trees-with-4grq0gwfpy.pdf

Fast Tree: Computing Large Minimum-Evolution Trees with Profiles instead of a Distance Matrix

Evolutionary trees describing the relationship for a set of species
 are central in evolutionary biology, and quantifying differences
 between evolutionary trees is therefore an important task. The
 quartet distance is a distance measure between trees previously
 proposed by Estabrook, McMorris, and Meacham. The quartet distance
 between two unrooted evolutionary trees is the number of quartet
 topology differences between the two trees, where a quartet topology
 is the topological subtree induced by four species. In this paper
 we present an algorithm for computing the quartet distance between
 two unrooted evolutionary trees of n species, where all internal
 nodes have degree three, in time O(n log n. The previous best
 algorithm for the problem uses time O(n
 2).

Computing the Quartet Distance between Evolutionary Trees in Time O ( n log n )

The cache oblivious model of computation is a two-level memory model with the assumption that the parameters of the model are unknown to the algorithms A consequence of this assumption is that an algorithm efficient in the cache oblivious model is automatically efficient in a multi-level memory model Arge et al recently presented the first optimal cache oblivious priority queue, and demonstrated the importance of this result by providingthe first cache oblivious algorithms for graph problems Their structure uses cache oblivious sorting and selection as subroutines In this paper, we devise an alternative optimal cache oblivious priority queue based only on binary merging We also show that our structure can be made adaptive to different usage profiles

/pdf/funnel-heap-a-cache-oblivious-priority-queue-1nm6i2fe07.pdf

Funnel Heap - A Cache Oblivious Priority Queue

We study the problem of sparse-matrix dense-vector multiplication (SpMV) in external memory. The task of SpMV is to compute y:=Ax, where A is a sparse N×N matrix and x is a vector. We express sparsity by a parameter k, and for each choice of k consider the class of matrices where the number of nonzero entries is kN, i.e., where the average number of nonzero entries per column is k.

We investigate what is the external worst-case complexity, i.e., the best possible upper bound on the number of I/Os, as a function of k, N and the parameters M (memory size) and B (track size) of the I/O-model. We determine this complexity up to a constant factor for all meaningful choices of these parameters, as long as k≤N 1−e , where e depends on the problem variant. Our model of computation for the lower bound is a combination of the I/O-models of Aggarwal and Vitter, and of Hong and Kung.

We study variants of the problem, differing in the memory layout of A. If A is stored in column major layout, we prove that SpMV has I/O complexity $\Theta(\min\{\frac{kN}{B}\max\{1,\log_{M/B}\frac{N}{\max\{k,M\}}\},\,kN\})$for k≤N 1−e and any constant 0<e<1. If the algorithm can choose the memory layout, the I/O complexity reduces to $\Theta ({\min\{\frac{kN}{B}\max\{1,\log_{M/B}\frac{N}{kM}\},kN\}})$for $k\leq\sqrt[3]{N}$. In contrast, if the algorithm must be able to handle an arbitrary layout of the matrix, the I/O complexity is $\Theta ({\min\{\frac{kN}{B}\max\{1,\log_{M/B}\frac{N}{M}\},kN\}})$for k≤N/2.

In the cache oblivious setting we prove that with tall cache assumption M≥B 1+e , the I/O complexity is $\mathcal {O}({\frac{kN}{B}\max\{1,\log_{M/B}\frac{N}{\max\{k,M\}}\}})$for A in column major layout.

/pdf/optimal-sparse-matrix-dense-vector-multiplication-in-the-i-o-7ybwzevv72.pdf

Optimal Sparse Matrix Dense Vector Multiplication in the I/O-Model

This paper is an algorithmic engineering study of cache-oblivious sorting. We investigate by empirical methods a number of implementation issues and parameter choices for the cache-oblivious sorting algorithm Lazy Funnelsort and compare the final algorithm with Quicksort, the established standard for comparison-based sorting, as well as with recent cache-aware proposals. The main result is a carefully implemented cache-oblivious sorting algorithm, which, our experiments show, can be faster than the best Quicksort implementation we are able to find for input sizes well within the limits of RAM. It is also at least as fast as the recent cache-aware implementations included in the test. On disk, the difference is even more pronounced regarding Quicksort and the cache-aware algorithms, whereas the algorithm is slower than a careful implementation of multiway Mergesort, such as TPIE.

/pdf/engineering-a-cache-oblivious-sorting-algorithm-3ipq60jimd.pdf

Engineering a cache-oblivious sorting algorithm

We study the following one-dimensional range reporting problem: On an array A of n elements, support queries that given two indices i ≤ j and an integer k report the k smallest elements in the subarray A[i..j] in sorted order. We present a data structure in the RAM model supporting such queries in optimal O(k) time. The structure uses O(n) words of space and can be constructed in O(n logn) time. The data structure can be extended to solve the online version of the problem, where the elements in A[i..j] are reported one-by-one in sorted order, in O(1) worst-case time per element. The problem is motivated by (and is a generalization of) a problem with applications in search engines: On a tree where leaves have associated rank values, report the highest ranked leaves in a given subtree. Finally, the problem studied generalizes the classic range minimum query (RMQ) problem on arrays.

/pdf/online-sorted-range-reporting-55emb8qezc.pdf

Rolf Fagerberg

Papers

Computing the Quartet Distance between Evolutionary Trees in Time O ( n log n )

Funnel Heap - A Cache Oblivious Priority Queue

Optimal Sparse Matrix Dense Vector Multiplication in the I/O-Model

Engineering a cache-oblivious sorting algorithm

Online Sorted Range Reporting