Refined Buneman Trees

C k−1 is an overapproximation of RB(δ| Xk−1 ), and C k is an overapproximation
of B xk (δ| Xk ).
Now we need to merge these two sets of splits. We will test each extended
split σ against the splits in C k : if σ is already in C k , we will ignore it. If σ
is incompatible with some split σ ′ ∈ C k (line 6), we will use the DISCARD-
RIGHT algorithm on the two splits to decide if σ ′ has non-positive refined
Buneman index (see chapter 9 for more details). If we decided σ ′ was not a
refined Buneman split, we will delete it from C k (line 8) and again measure if σ
is incompatible with some new split σ ′ ∈ C k (line 9). Finally, if we have decided
that σ qualifies, we will insert it into our compatible set of splits (lines 11–12).
The time complexity analysis for this first part of the algorithm goes like
this: bootstrapping a tree of size 4 in line 1 of the algorithm takes constant
time. We then in line 2 iterate over at most n species. In line 3 we build a
single linkage clustering tree in time O(n 2 ). In line 4 we iterate over all splits
in an unrooted tree, there are O(n) of those. Each of the algorithms INCOM-
PATIBLE, INSERT, DELETE and DISCARD-RIGHT take time O(n). For
the while loop in line 7 we can only find O(n) splits in an unrooted tree that
can possibly be incompatible with σ, so the first part of the algorithm runs in
time O(n 3 ).
The space usage consists of holding two compatible sets of splits at any one
time and the space required to calculate the single linkage clustering trees. We
can store any compatible set of splits in linear space using the tree data structure
described in chapter 6. It is much worse for the single linkage clustering tree,
the implementation in this paper uses a quad tree data structure, which will
allocate Θ(n 2 ) space. Of course, we already need space for the distance data,
which is also Θ(n 2 ). So in total we need to use space Θ(n 2 ) for the first part of
the algorithm.
5.2 Pruning
The second part of the algorithm deals with the extraction of refined Buneman
splits from a the set of compatible splits constructed in the first part of the
algorithm. Denote this set T . In the context of (evolutionary) trees and bioinformatics,
we might call this part pruning, even though we shall not actually
remove any edges from T — our tree data structure cannot handle a tree topology
which is not a regular, leaf-labeled tree, so we will only invalidate edges
instead of changing the topology of the tree.
In this part of the algorithm, we shall look at all splits in T by considering
all edges in the tree, and calculate refined Buneman indices for the splits they
represent. Finally we shall report those splits which have positive refined Buneman
index. We will do this by first decorating all edges in T with their refined
Buneman index, or 0 as a special marker for invalid splits. Later we extract the
refined Buneman splits from T in quadratic time — linear time iteration over
edges, and for each edge, linear time for reporting n bits in a bitvector. So our
so-called pruning algorithm is in reality a searching-and-scoring algorithm, and
35