AbstractAddressing a problem of Fredman and Willard, we implement fusion trees in deterministic linear space using AC0 instructions only. More precisely, we show that a subset of {0,…,2w - 1} of size n can be maintained using linear space under insertion, deletion, predecessor, and successor queries, with O(log nlog log n) amortized time per operation on a RAM with word size w, where the only computational instructions allowed on the RAM are functions in AC0. The AC0 instructions used are not all available on today's computers

Andersson, Arne

Miltersen, Peter Bro

Thorup, Mikkel

Elsevier - Publisher Connector 

Theoretical 
Computer Science 
ELSEVIER Theoretical Computer Science 215 (1999) 337-344 
Note 
Fusion trees can be implemented with AC0 instructions only 
Arne Andersson +*, Peter Bro Miltersen b,l, Mikkel Thorup’ 
a Department qf’ Computer Science, Lund University, P. 0. Box 117, S-221 00 Lund, Sweden 
b BRICS2, University of Aarhus, Denmark 
’ University of Copenhagen, Denmark 
Received September 1996; revised October 1997 
Communicated by M.S. Paterson 
Abstract 
Addressing a problem of Fredman and Willard, we implement fusion trees in deterministic 
linear space using AC0 instructions only. More precisely, we show that a subset of (0,. ,2” - 
1 } of size n can be maintained using linear space under insertion, deletion, predecessor, and 
successor queries, with O(log n/log log n) amortized time per operation on a RAM with word 
size w, where the only computational instructions allowed on the RAM are functions in AC”. 
The AC0 instructions used are not all available on today’s computers. @ 1999-Elsevier Science 
B.V. All rights reserved 
1. Introduction 
Fredman and Willard [5], based on earlier ideas of Ajtai et al. [l], introduced 
the fusion tree. A fusion tree is a data structure maintaining a subset S of U = 
{0,1,...,2”-‘} d un er insertions, deletions, predecessor and successor queries (i.e. for 
any element x of U, we can find the predecessor and successor of x in S). The model 
of computation for the fusion tree is a random access machine whose registers contain 
w-bit words (i.e. members of U), and with an instruction set which includes unit-cost 
addition, subtraction, multiplication, comparison, and bit-wise Boolean AND. The fusion 
tree maintains a set of size n using O(n) space and amortized time O(1og n/log log n) 
per operation. An immediate corollary to the existence of the fusion tree is that n w-bit 
’ Supported by the ESPRIT Long Term Research Programme of the EU under project number 20244 
(ALCOM-IT). 
’ Basic Research in Computer Science, Centre of the Danish National Research Foundation, 
*Corresponding author. E-mail: arne@dna.lth.se 
0304-3975/99/$ ~ see front matter @ 1999-Elsevier Science B.V. All rights reserved 
PII: SO304-3975(98)00172-S 
338 A. Andersson et al. I Throreticul Computer Scienw 215 (1999) 337-344 
keys can be sorted in time O(n log n/log log n) and space O(n) on a RAM with word 
size w. 
Fredman and Willard point out that multiplication is not an AC0 instruction, that is, 
there are no circuits for multiplication of constant depth and of size (number of gates) 
polynomial in the word length. Here, the gates are negations, and A- and V-gates with 
unbounded fan-in. They pose as an open question if the fusion tree can be implemented 
using AC0 instructions only. One motivation for this question is that AC0 is the class 
of functions which can be computed in constant time in a certain, reasonable, model 
of hardware. In this model, it is therefore the class of functions for which we can 
reasonably assume unit cost evaluation. 
In this paper, we solve this problem by showing that, given a small set of non- 
standard AC0 instructions in addition to the more standard ones available in program- 
ming languages such as C (e.g. addition, comparison, bitwise Boolean operations, and 
shifts), the fusion tree can be implemented, with the same asymptotic space and time 
bounds as in [5]. 
Our presentation can also be seen as an alternative explanation of the basic mecha- 
nisms in fusion trees. We believe that our use of special-purpose instructions in place 
of the ingenious use of multiplication in [5] may make our presentation easier to under- 
stand for the casual reader. Thus, we argue that not only the use of non-AC’ operations, 
but also much of the technical complexity of fusion trees, are artifacts of the particular 
choice of instructions in current hard-ware. 
It should be noted that the transformation to AC’ operations presented in this paper, 
can be applied similarly to the atomic heaps and q-heaps in Fredman and Willard’s 
later paper [6]. 
2. Model of computation and notation 
We use a RAM with word size w and we consider n w-bit keys that can be treated 
as binary strings or (unsigned) integers. Note that since n is the size of a subset of 
(0,. ‘. , 2” - I}, we have that w 3 log ~1. We shall also assume that Jt; is a power of 
tW0. 
A w-bit word will sometimes be viewed as a concatenation of fi Jields. Each field 
is of length Jt;- 1; to the left of each field is the test bit of the field. By a bit pointer 
we mean a (log w)-bit key; such a key can be used to specify a bit-position within 
a word. Without loss of generality, we assume that log w < fi - 1 and hence a bit 
pointer fits in a field. As an example, if w = 64 a word contains 8 fields of length 7, 
one test bit is stored with each field. 
We will use upper-case characters to denote words and lower-case characters to 
denote fields. For any bit-string a, we use Ia] to denote its length, and for i = 1,. . . ,IKI, 
a[i] is the ith bit in 2. In particular, a[l] is the leftmost, and ~[lal] is the rightmost 
bit of CL Also, for 1 <i<j,<lcl, z[i..j] = a[i] ..sab]. Finally, int(cc) is the number 
represented by CI, i.e. int(a) = C/.$’ 2’c([]a( - i]. Note that our indexing of words 
A. Anderson et al. I Theoretical Computer Science 215 (1999) 337-344 339 
is slightly non-standard; it is more common to index words from right to left, starting 
with 0. However, in the main technical part of this paper it is most convenient to 
think of words as strings, and these are usually indexed from left to right starting with 
index 1. 
Apart from the standard AC0 instructions (comparison, addition, bitwise Boolean 
operations and shift), we use the following ones: 
LeftmostOne( returns a bit pointer to the leftmost 1 in X. A simple depth 2 circuit 
of quadratic size is indicated by: 
i-l 
Vi <w : int (LeftmostOne( = i W ( 1 A 7x[j] A x[i]. j=l 
In fact, LeftmostDne(X) can be implemented using a constant number of instructions 
available on present day chips and in programming languages such as C: we just need 
to convert X to floating point representation and afterwards return the exponent. 
Duplicate(x,d): Returns a word containing copies of the field x in the d rightmost 
fields. 
Select(X,K): The first fi - 1 fields in K are viewed as bit pointers; a field is 
returned, containing the selected bits in X. Not all fields of K need to be used. 
The test bit of a used field is 1. A depth 3 circuit of size 0(w3i2) is indicated by 
Vi < h : Select(X, K)[i + I] 
= K[(i - 1)(6 + 1) + 11 A qti = int(K[(i - l)(h + 1) + 2..i(b + l)]) AXIJ). 
j=l 
Furthermore, we assume that the constants b = fi - 1 and k = log fi are known, 
b is the length of the field. 
3. The AC0 fusion tree 
Lemma 1. Let d be an integer, smaller than or equal to fi. Let Y be a word where 
the d rightmost fields contain one b-bit key each. Furthermore, assume that the d 
keys are sorted right-to-left, the d rightmost test bits are 0, and that all bits to the 
left of the d used fields (and their test bits) are 1. Then, given a b-bit key x, we can 
compute the rank of x among the keys in Y in constant ime. 
Proof. The crucial observation is due to Paul and Simon [7]; they observed that one 
subtraction can be used to perform comparisons in parallel. 
Let M be a word where the d rightmost test bits are 1 and all other bits are 0. 
In order to compute the rank of x among the keys in Y, we place d copies of x in 
the d rightmost fields of a word X. We let the test bits of those fields be 1. By the 
assignment R +- (X - Y) AND M the ith test bit from the right in R will be 1 if and 
340 A. Andersson et (11. I Theoretical Computer Science 215 (1999) 337-344 
only if x2 yi. All other test bits (as well as all other bits) in R will be 0. Hence, from 
the position of the leftmost 1 in R we can compute the rank of x. 
We implement this in the function PackedRank below. First, we compute d, the 
number of keys contained in Y. This is the same number as the number of set test 
bits in NOT Y, which can be determined using the function LeftField below. Next, 
we create the word X and the mask M. Finally, we make the subtraction and extract 
the rank. 
For clarity, we introduce two simple AC0 functions. 
FillTestBits(d): returns a word where the d rightmost test bits are set and all other 
bits are zeroes. Can be implemented with shift, bitwise logical operations, and 
Duplicate. 
LeftField( If the leftmost 1 in Y is a test bit, and if all test bits to the right of 
this test bit are set, the number of set test bits is returned. This can be computed 
as b + 1 - (Lef tmostOne(Y) - l)/(b + 1). We do not have a division operation, 
but since b + 1 = 2k, we can implement the division by a right shift by k. 
Algorithm A: PackedRank (Y,x) 
A.l. d + LeftField(NOT Y). 
A.2. A4 + FillTestBits(d). 
A.3. X + Duplicate(x,d) OR A4. 
A.4. R + (X - Y) AND M. 
A.5. return LeftField( 
PackedRank clearly runs in constant time. 0 
Lemma 2. Given a word Y and a key x as in Lemma 1, with d strictly less than 
,,4 we can generate a new word where x is properly inserted among the keys in Y 
in constant time. 
Proof. We need a function InsertField(Y,x, i) which inserts x as the (i + 1)‘st field 
from the right in Y, pushing fields to the right of the (i + 1)‘st field one field to the 
right, and sets x’s test bit to 0. This can easily be implemented with shift and bitwise 
Boolean operations. 
The function InsertKey below implements the lemma. 
Algorithm B: InsertKey (Y,x) 
B. 1. return InsertField( Y,x, PackedRank( Y,x)). 
4. Fusion tree nodes 
In this section we give our version of the main building block of fusion trees. 
A. Andersson et al. I Theoretical Computer Science 215 (1999) 337-344 341 
Proposition 3. Given d sorted w-bit keys, d < fi, we can construct, in O(d) time, u 
static data structure using O(d) space, so that predecessor and successor queries can 
be supported in 0( 1) worst case time. 
We use such a data structure to represent each node of the fusion tree. Our construction 
emulates the construction used by Fredman and Willard very closely. However, since 
we want our presentation to be self-contained, we devote this section to give all the 
details of the construction. 
The main idea is to make use of significant bit positions. View the set of w-bit 
sorted keys Yl,. . , Yd as stored in a binary trie. Each key is represented as a path 
down the trie, a left edge denotes 0 and a right edge denotes 1. We get the significant 
bit positions by selecting the levels in the trie where there is at least one binary (that 
is, non-unary) node. These bit positions can be computed by taking the position of 
the first differing bit between all pairs of adjacent keys in Y,, . . . , Yd. By extracting the 
significant bits from each key we create a set of compressed keys yi, . . . , yd. Since the 
trie has exactly d leaves, it contains exactly d - 1 binary nodes. Therefore, the number 
of significant bit positions, and the length of a compressed key, is at most d - 1. Since 
d-16,./G-l=b, we can pack these compressed keys in linear time by repeated 
calls to InsertKey in Lemma 2. 
We need the following AC0 functions, which can be implemented in a straightforward 
way: 
DiffPtr(X, Y): returns a bit pointer to the leftmost differing bit between X and Y. 
(Can be implemented as LeftmostOne(X XOR Y).) 
Fill(X, p): X is a word and p is a bit pointer. Returns a copy of X where all bits 
to the right of position p have the same value as the bit in position p. If p = w + 1, 
Fill@& p) = X. (Can be implemented by shifting, addition, and bitwise Boolean 
operations.) 
The procedure Construct takes as input a set of sorted keys Yi, . . . , Yd and computes 
the set of significant bit positions; pointers to these positions are concatenated in sorted 
order in the word K. Next, a set of compressed keys is created by selecting the bits 
specified in K from Yi, . . . , rd. These compressed keys are packed in the word Y. 
Algorithm C: Construct (Yi, . . . , Yd) 
C.l. K 6 0. 
C.2. For i + 1 to d - 1, K +- InsertKey(K,Dif fPtr( Yj, Y;+l)). 
c.3. Y + 0. 
C.4. For i + 1 to d, Y + InsertKey (Y, Select(Yi,K)). 
When implemented as above, the same bit-pointer may be packed several times in 
K. This makes no difference. 
We can now compute the rank of a query key X in constant time. Let x = 
Select(X,K) and let px denote the longest common prefix of X and any key in 
YI >. ., Yd. Let yi denote the compressed version of Y. Let q1 < q2 < . . < qd- I be 
342 A. Andersson et al. I Theoretical Computer Science 215 (1999) 337-344 
the significant bit positions and let qd = w + 1. Then x[j] = X[qi] and y,[j] = yi[qj]. 
Note that if y;,[l..j] = yi,[l..j], then Y;,[l..qj+r - l] = Y;z[l..gj+l - I]. 
Lemma 4. If x hus rank i in yl, . . . , yd, then either Y, or Yi+l start by px. 
Proof. Let i’ be such that Yir has the prefix px. Let j be the maximal index such that 
qj < Ipx 1. Then yif [ l..j] = x[ l..j]. However, since i is the rank of x, we either have 
x = y, or y, < x < yl+i. This means that for i” equal to either i or i + 1, we have 
y;tt[l..j] = yit[l..j]. Hence Yi/f[l..qj+l - l] = Y;,[l..qj+i - I], but q5+i - 1 >]px], SO 
Yjff must share the prefix px with Y,. 0 
Lemma 5. Consider a key Z that starts by px and where all remaining bits in Z 
have the same value as X’s ,jirst distinguishing bit, i.e. the bit of X following px. 
Set z = Select(Z,K). Let z” be the result of setting the last bit of z to 0, and let 
z’ be the result of setting it to 1. Then z E {zO,z’}, and then the runk of X among 
YI,. . . , Yd is either that of z” or that of z’ among yl,. . . , ~(1. 
Proof. Clearly, Z has the same rank as X among Y1,. . . , rd. Let i be the rank of z 
among yl,..., yd. If yi # z, then i is the correct rank of X. The same holds if Y; = 
Z = X. However, suppose that yi = z and x # Z. Suppose that the first distinguishing 
bit X[]px] + l] ofX is 0. Then there is some j > 1~x1, j $ {q1,...,q&1}, such that 
YilJ = 1. Hence Y > Z. Since yij = yi implies Y,, = Y, we conclude that the rank 
of Z among Yr,. . , Y<f is the rank of z’ among yi,. . . , yd. 
If X[ Ipx / + l] = 1, symmetrically we have that the rank of Z among Yi, . . . , Yd is 
the rank of z” among ~1,. . . , yd. 0 
We can use Lemma 4 to compute the length of px and hence the position of X’s 
first distinguishing bit. Once this position is known, we can apply Lemma 5 to find 
the proper rank of X. 
We encode this in the function Rank below. The variable p is used to store the 
position of X’s first distinguishing bit. This is the only place in this section where we, 
for convenience, deviate slightly from Fredman and Willard’s original method: Instead 
of filling the query keys with 1s (or OS) and making a second packed searching, they 
use a lookup table of size O(d*) in a node of degree d. 
Algorithm D: Rank(X) 
D. 1. i + PackedRank( Y, Select(X, K)). 
D.2. If i = 0, p + DiffPtr(X, Yi); 
D.3. else p + max(DiffPtr(X, Yi),DiffPtr(X, Y+i)) 
D.4. Z + Fill(X, p). 
D.5. z c Select(Z,K). 
D.6. i + PackedRank(Y,z). 
D.7. If K<Z < K+i, return i; 
D.8. else z[b] +- -z[b]; return PackedRank(Y,z). 
A. Andersson et al. I Theoretical Computer Science 215 (1999) 337-344 343 
Now to find the predecessor of a value in the set, we find the rank of the value, 
and the predecessor can now be found by a table lookup in the sorted table of the set. 
This completes the proof of Proposition 3. 
5. The fusion tree 
Having dealt with fusion nodes, the proof of our main theorem is virtually the same 
as that of Fredman and Willard. Note that we can allow the B-tree nodes to have 
higher degree than in the original fusion tree: fi compared to ~‘1~. 
Theorem 6. A set of word-sized integers can be maintained using linear space un- 
der insertion, deletion, predecessor, and successor queries, with O(log nJlog log n) 
amortized time per operation on an AC0 RAM. 
Proof. The proof proceeds as in [5]: 
Proposition 3 allows us to implement a B-tree [2] node of degree d < fi. Searching 
in such a node takes constant time while splitting, merging, and adding/removing keys 
take O(d) time. By keeping traditional, comparison-based, weight-balanced trees of size 
O(d) at the bottom of the B-tree, we can ensure that at most every O(d)‘th update 
causes any change in a B-tree node. 
The number of B-tree levels is O(log n/log d) and the height of a weight-balanced 
tree is O(log d). Since w 3 log n, we can choose d = O( fi) and the theorem 
follows. 0 
As a final remark, we note that applying a result of Dietz [3], we can also support 
rank-operations within the O(log n/log log n) time bound. Dietz showed that a list of 
atoms can be maintained under the operations insert, which inserts a new atom after a 
specified position in the list, delete, which deletes an atom from the list, and position, 
which, given an atom, returns its position in the list, in time O(log n/log log n) per 
operation. Dietz’ list maintenance structure uses only a very basic, AC’, instruction set. 
Using the predecessor query of a fusion tree maintaining a set, we can make Dietz’ 
structure maintain a sorted list of the elements of the set. Then, to find the rank in 
the set of a new value, we just need to find the position in the list of its predecessor 
in the set. Hence, rank-queries are supported in time O(log n/log log n) in addition 
to the other operations. This matches a lower bound by Fredman and Saks [4] which 
holds without any assumptions on the instruction set. 
References 
[I] M. Ajtai, M.L. Fredman, .I. Komlos, Hash functions for priority queues, Inform. Comput. 63 (1984) 
217-225. 
[2] R. Bayer, E.M. McCreight, Organization and maintenance of large ordered indexes, Acta Inform. l(3) 
(1972) 173-189. 
344 A. Andersson et ul. I Theorerical Computer Science 215 (1999) 337-344 
[3] P.F. Dietz, Optimal algorithms for list indexing and subset rank, in: Proc. 1st Workshop on Algorithms 
and Data Structures (WADS), Lecture Notes in Computer Science, vol. 382, Springer, Berlin 1989, pp. 
3946. 
[4] M.L. Fredman, M.E. Saks, The cell probe complexity of dynamic data structures, in: Proc. 21th ACM 
Symp. on Theory of Computing (STOC), 1989, pp. 3455254. 
[5] M.L. Fredman, D.E. Willard, Surpassing the information theoretic bound with fusion trees, J. Comput. 
System Sci. 47 (1993) 424436. 
[6] M.L. Fredman, D.E. Willard, Trans-dichotomous algorithms for minimum spanning trees and shortest 
paths, J. Comput. System Sci. 48 (1994) 533-551. 
[7] W. J. Paul, J. Simon, Decision trees and random access machines, in: Proc. Intemat. Symp. on Logic 
and Algorithmic, Zurich, 1980, pp. 331-340. 


Fusion trees can be implemented with AC0 instructions only 

file:///data/remote/core/dit/data/elsevier/pdf/16b/aHR0cDovL2FwaS5lbHNldmllci5jb20vY29udGVudC9hcnRpY2xlL3BpaS9zMDMwNDM5NzU5ODAwMTcyOA==.pdf

Fusion trees can be implemented with AC0 instructions only

Abstract

Similar works

Full text

Available Versions

Elsevier - Publisher Connector

Elsevier - Publisher Connector