A non classical approach to the logic synthesis of Boolean functions based on switching lattices is considered, for which deriving a feasible layout has not been previously studied. The problem presents new interesting combinatorial and algorithmic aspects. Our basic assumptions are that the positions of the switches in the lattice are fixed in the synthesis stage, and the layout for connecting the subsets of switches with the same input literal must be realized in superimposed planes through vias that take the same switch area. The overall goal is to minimize the number of layers needed. Since multiple choices of input literals are possible for each switch, we first study how to assign a single literal to each switch, to minimize the number of lattice portions of adjacent cells associated to the same literal (Problem 1). Then we study how to derive a feasible layout by building connections onto different layers, to minimize the number of layers (Problem 2). Problem 1 is NP-hard. Problem 2 seems to be also intractable, and exhibits limit instances that require an exceedingly number of layers or are even unsolvable. Heuristic algorithms are then developed for both problems and their encouraging performances are proved on a set of known benchmarks.

Trees are a fundamental structure in algorithmics. In this paper, we study the transformation of an arbitrary binary tree S with n vertices into a completely balanced tree T via rotations , a widely studied elementary tree operation. Combining concepts on rotation distance and data structures, we give a basic algorithm that performs the transformation in Θ( n ) time and Θ(1) space, making at most 2 n − 2 log 2n rotations and improving on known previous results. The algorithm is then improved, exploiting particular properties of S . Finally, we show tighter upper bounds and obtain a close lower bound on the rotation distance between a zig-zag tree and a completely balanced tree. We also find the exact rotation distance of a particular almost balanced tree to a completely balanced tree, and thus show that their distance is quite large despite the similarity of the two trees.

Network decontamination is studied on a k-dimensional torus (n1times ldrldrldr times nk), with k ges 1 and 2 les n1lesldrldrldrles nk. The decontamination is done by a set of agents moving on the net according to a new cleaning model. After an agent leaves from a vertex, this vertex remains uncontaminated as long asmneighbors are uncontaminated. We propose algorithms valid for any m les 2k (i.e., up to the vertex degree), proving that A(k, m) synchronous agents suffice, with: A(k, 0) = 1; A(k, m) = 2m-1, for 1 les m les k + 1; A(k, m) = 22k-m+1n1n2ldrldrldr nm-k-1, for k + 2 les m les 2k. We also study the total number M(k, m) of agent moves, and prove matching lower bounds on A(k, m) and M(k, m) valid form = 3 and any k, and for all m ges k+1. Our study can be simply extended to asynchronous functioning.

Consider an ordered, static tree T where each node has a label from alphabet Σ. Tree T may be of arbitrary degree and shape. Our goal is designing a compressed storage scheme of T that supports basic navigational operations among the immediate neighbors of a node (i.e. parent, i th child, or any child with some label,…) as well as more sophisticated path -based search operations over its labeled structure. We present a novel approach to this problem by designing what we call the XBW-transform of the tree in the spirit of the well-known Burrows-Wheeler transform for strings [1994]. The XBW-transform uses path-sorting to linearize the labeled tree T into two coordinated arrays, one capturing the structure and the other the labels. For the first time, by using the properties of the XBW-transform, our compressed indexes go beyond the information-theoretic lower bound, and support navigational and path-search operations over labeled trees within (near-)optimal time bounds and entropy-bounded space. Our XBW-transform is simple and likely to spur new results in the theory of tree compression and indexing, as well as interesting application contexts. As an example, we use the XBW-transform to design and implement a compressed index for XML documents whose compression ratio is significantly better than the one achievable by state-of-the-art tools, and its query time performance is order of magnitudes faster.

We introduce a new paradigm for querying strings in external memory, suited to the execution of sequences of operations. Formally, given a dictionary of n strings S1, …, Sn, we aim at supporting a search sequence for m not necessarily distinct strings T1, T2, …, Tm, as well as inserting and deleting individual strings. The dictionary is stored on disk, where each access to a disk page fetches B items, the cost of an operation is the number of pages accessed (I/Os), and efficiency must be attained on entire sequences of string operations rather than on individual ones.

We consider the problem of decontaminating a network infected by a mobile virus. The goal is to perform the task using as small a team of antiviral agents, avoiding any recontamination of disinfected areas, and minimizing the amount of agents' movements across the network. In all the existing literature, it is assumed that the immunity level of a disinfected site is nil. In this paper we consider the network decontamination problem under a new model of immunity to recontamination: we consider the case when a disinfected vertex, after the cleaning agent has gone, will become recontaminated only if a weak majority of its neighbours are infected. We study the effects of this level of immunity on the number of antiviral agents necessary to decontaminate the entire network. We focus on tori and on trees, and establish lower-bounds on the team size; we also establish lower bounds on the number of moves performed by an optimal-size time of cleaners. We design and present strategies for disinfecting tori and trees; we prove that these strategies are optimal in terms of both team size and number of moves. In particular, the upper and lower bounds are tight for tree networks and for synchronous tori; the bounds are within a constant factor of each other in the case of asynchronous tori.

XML is fast becoming the standard format to store, exchange and publish over the web, and is getting embedded in applications. Two challenges in handling XML are its size (the XML representation of a document is significantly larger than its native state) and the complexity of its search (XML search involves path and content searches on labeled tree structures). We address the basic problems of compression, navigation and searching of XML documents. In particular, we adopt recently proposed theoretical algorithms [11] for succinct tree representations to design and implement a compressed index for XML, called XBZIPiNDEX, in which the XML document is maintained in a highly compressed format, and both navigation and searching can be done uncompressing only a tiny fraction of the data. This solution relies on compressing and indexing two arrays derived from the XML data. With detailed experiments we compare this with other compressed XML indexing and searching engines to show that XBZIPiNDEX has compression ratio up to 35% better than the ones achievable by those other tools, and its time performance on some path and content search operations is order of magnitudes faster: few milliseconds over hundreds of MBs of XML files versus tens of seconds, on standard XML data sources.

Consider an ordered, static tree /spl Tscr/ on t nodes where each node has a label from alphabet set /spl Sigma/. Tree /spl Tscr/ may be of arbitrary degree and of arbitrary shape. Say, we wish to support basic navigational operations such as find the parent of node u, the ith child of u, and any child of it with label /spl alpha/. In a seminal work over fifteen years ago, Jacobson (1989) observed that pointer-based tree representations are wasteful in space and introduced the notion of succinct data structures. He studied the special case of unlabeled trees and presented a succinct data structure of 2t + o(t) bits supporting navigational operations in O(1) time. The space used is asymptotically optimal with the information-theoretic lower bound averaged over all trees. This led to a slew of results on succinct data structures for arrays, trees, strings and multisets. Still, for the fundamental problem of structuring labeled trees succinctly, few results, if any, exist even though labeled trees arise frequently in practice, e.g. in the data as in markup text (XML) or in augmented data structures. We present a novel approach to the problem of succinct manipulation of labeled trees by designing what we call the xbw transform of the tree, in the spirit of the well-known Burrows-Wheeler transform for strings. The xbw transform uses path-sorting and grouping to linearize the labeled tree /spl Tscr/ into two coordinated arrays, one capturing the structure and the other the labels. Using the properties of the xbw transform, we (i) derive the first-known (near-)optimal results for succinct representation of labeled trees with O(1) time for navigation operations, (ii) optimally support the powerful subpath search operation for the first time, and (iii) introduce a notion of tree entropy and present linear time algorithms for compressing a given labeled tree up to its entropy beyond the information-theoretic lower bound averaged over all tree inputs. Our xbw transform is simple and likely to spur new results in the theory of tree compression and indexing, and may have some practical impact in XML data processing.

We exploit the "regularity" of Boolean functions with the purpose of decreasing the time for constructing minimal three-level expressions, in the sum of pseudoproducts (SPP) form recently developed. The regularity of a Boolean function f of n variables can be expressed by an autosymmetry degree k (with 0 /spl les/ k /spl les/ n). k = 0 means no regularity, that is we are not able to provide any advantage over standard synthesis. For k /spl ges/ 1 the function f is said to be autosymmetric, and a new function f/sub k/ depending on n - k variables only, called the restriction of f, is identified in time polynomial in the number of points of f. The relation between f and f/sub k/ is discussed in depth to show how a minimal SPP form for f can be build in linear time from a minimal SPP form for f/sub k/. The concept of autosymmetry is then extended to functions with don't care conditions, and the SPP minimization technique is duly extended to such functions. A large set of experimental results is presented, showing that 61% of the outputs for the functions in the classical ESPRESSO benchmark suite are autosymmetric. The minimization time for such functions is critically reduced, and cases otherwise intractable are solved. The quality of the corresponding circuits, measured with some well established cost functions, is also improved. Finally, we discuss the role and meaning of autosymmetric functions, and why a great amount of functions of practical interest fall in this class.

Sum of Pseudoproducts (SPP) is a three level logic synthesis technique developed in recent years. In this framework we exploit the "regularity" of Boolean functions to decrease minimization time. Our main results are: 1) the regularity of a Boolean function f of n variables is expressed by its autosymmetry degree k (with 0 ≤ k ≤ n), where k = 0 means no regularity (that is, we are not able to provide any advantage over standard synthesis); 2) for k ≥ 1 the function is autosymmetric, and a new function fk is identified in polynomial time; fk is "equivalent" to, but smaller than f, and depends on n-k variables only; 3) given a minimal SPP form for fk a minimal SPP form for f is built in linear time; 4) experimental results show that 61% of the functions in the classical Espresso benchmark suite are autosymmetric, and the SPP minimization time for them is critically reduced; we can also solve cases otherwise practically intractable. We finally discuss the role and meaning of autosymmetry.

Data warehouses are increasingly storing and managing large scale string data, and dealing with large volume of transactions that update and search string data. Motivated by this context, we initiate the study of self-adjusting data structures for string dictionary operations, that is, data structures that are designed to be efficient on an entire sequence rather than individual string operations. Furthermore, we study this problem in the external memory model where string data is too massive to be stored in internal memory and has to reside in disks; each access to a disk page fetches B items, and the cost of the operations is the number of pages accessed (I/Os).

We introduce the new masked interval routing scheme (MIRS), where a mask is added to each interval to indicate particular subsets of `consecutive' labels. We show that the interval information stored in the network is drastically reduced in some hard cases, proving first that in globe graphs of O$(N)$ vertices the number of intervals per edge goes down from $\Omega(\sqrt{N})$, as required in the classical interval routing scheme (IRS), to O$(\log N)$ in MIRS. The technique is also extended to globe graphs of arbitrary dimensions. The advantage of using MIRS is then demonstrated for butterfly graphs, where we prove that the number of intervals per edge goes down from $\Omega(\sqrt{{N}/{\log N}})$ to O$(\log N)$. This paper is aimed at introducing a new technique. The examples provided show that MIRS is powerful to some extent in the reduction of the number of labels, and may be useful in practice. This work represents a possible new direction for further research.

Consider a hypercube of 2/sup n/ points described by n Boolean variables and a subcube of 2/sup m/ points, m/spl les/n. As is well-known, the Boolean function with value 1 in the points of the subcube can be expressed as the product (AND) of n-m variables. The standard synthesis of arbitrary functions exploits this property. We extend the concept of subcube to the more powerful pseudocube. The basic set is still composed of 2/sup m/ points, but has a more general form. The function with value 1 in a pseudocube, called pseudoproduct, is expressed as the AND of n-m EXOR-factors, each containing at most m+1 variables. Subcubes are special cases of pseudocubes and their corresponding pseudoproducts reduce to standard products. An arbitrary Boolean function can be expressed as a sum of pseudoproducts (SPP). This expression is in general much shorter than the standard sum of products, as demonstrated on some known benchmarks. The logical network of an n-bit adder is designed in SPP, as a relevant example of application of this new technique. A class of symmetric functions is also defined, particularly suitable for SPP representation.

A recent encoding method [11 is revisited here, and two simple variations are proposed to reduce the length of the encoded data strings. The new variations also decrease encoding time, and allow numerical data to be represented in any base.

A VLSI chip for performing relational data base operations is proposed. The chip is a tree of processors (TOP), where each chip has elementary storage and processing capabilities. A relation will be stored in the lowest levels of a TOP. More precisely, every m-tuple will occupy a subtree whose root is s= [log2(m+1)] =1 levels above the leaves. Denoting by h the height of the tree, the upper h-s levels will be used for routing and bookkeeping purposes. A number of basic operations such as allocate and deallocate subtrees, insert and compare m-tuples etc., are defined for the TOP's. Relational operations are effectively performed as simple combinations of basic operations. The architecture of a data base machine based on TOP's is also sketched. Such a machine is feasible with the current VLSI technology and could become attractive in few years if density and performance of VLSI keep improving at the current rate.

A typical organization of magnetic bubble memories is the major-minor loop structure, where n (minor) loops are connected via switches to another (major) loop, containing the I/O station. We work on a sorted file F, split into subfiles allocated in the minor loops.

In this paper the problem of sorting in various models of magnetic bubble memory systems is studied. Three basic parameters are of interest, namely, the number of steps to sort, the number of switches required, and the number of control states necessary for the switches. Several sorting algorithms are proposed with respective running times essentially n2, n/2, 1/2 n log2 n, 7/2 n, n log2n, respective numbers of switches essentially, 1, n, 2√n, 2√nlog2n , 1og2n, and respective numbers of control states essentially, 3, 2, 1/8 log2n, 1/8 log2n, and 3 log2n.

In this paper, we study the problem of maintaining a file in magnetic bubble memories. A memory structure with a special loop ordering scheme is proposed, in which records are stored in a balanced tree form. Algorithms for searching, insertion, and deletion are proposed. They have the property that, after each operation, the file is restored to a balanced tree form. The searching operation takes time log22 n/(2 log2 log2 n) + O(log2 n) where n is the number of records in the file, while insertion and deletion take additional log2 n + O(1) time each. This scheme, however, requires that each switch be individually settable. In the latter part of the paper, the memory is slightly modified, and a new loop ordering scheme proposed. With only two control operations, we show that searching, insertion, and deletion of records in the tree can still be done although the tree can no longer be kept in balanced form. If the tree is balanced, then searching, insertion, and deletion take only 5/2 log2 (n + 1) + O(1) time each.

A new balancing technique for binary search trees is presented, based on the repositioning of k + 1 nodes (k-rotation) Some properties of k-rotation are shown, and bounds to k are derived. The performance of such a technique is discussed on the basis of the length of node search and the frequency of tree rebalancing.

Height-balanced binary trees with height unbalances up to Δ are investigated, and the asymptotic value of the height h of such trees is studied for an increasing number of nodes N. It is shown that, in the worst case, the asymptotic value of h is a logarithmic function of N: [h = K log N]n→∞. Specifically, an upper bound for h can be posed as: h ≤ K1log (N+2) - K2for Δ ≤ 3; and h ≤ K1log (N+K2) - K3for Δ = 4. Less strict bounds are posed for Δ > 4.

ASSTRACT.Let U1 , U2, . . ., Ud be totally ordered sets and let V be a set of n d-dimensional vectors In U~ X Us. .X Ud .A partial ordering is defined on V in a natural way The problem of finding all maximal elements of V with respect to the partial ordering ~s considered The computational complexity of the problem is defined to be the number of required comparisons of two components and is denoted by Cd(n).It is tnwal that C~(n) = n -1 and C,~(n) < O(n 2) for d _~ 2 In this paper we show: ( 1) C2(n) = O(n logan) for d = 2, 3 and Cd(n) ~ O(n(log2n) ~-~) for d ~ 4, (2) C,t(n) >_ flog2 n!l for d _> 2 KEY WORDS AND PHRASES: maxima of a set of vectors, computattonal complexity, number of comparisons, algorithm, recurrence CR CATEaOmES.5.25, 5,31, 5.39 IntroductionLet U1, U2_, • • • , Ud be totally ordered sets and let V be a set of n d-dimensional vectors in the Cartesian product Ui X U2 X • • • X Ud.For any vector v in V, let x,(v) denote the zth component of v.A partial ordering < is defined on V in a natural way, that is, for v, u E V, v < u if and only if x,(v) <, x,(u) for all z = 1, ... , d, where _<, is the total ordering on U,. (We shall often write <_ for <,.The context should make clear the meaning of < .)For v C V, v is defined to be a maximal element (or, briefly, a maximum) of V if there does not exist u E V such that u ~ v and u ~ v.We consider the problem of finding all maximal elements of V.The computational complexity of the problem is defined to be Cd(n) = min max Ca(A, V),

A new method of description of a straight line defined on a square grid is presented. The discrete equation of the straight line (desl) is introduced as an extension of the classical Cartesian equation, and applies to straight lines quantized on a grid by the grid intersect method. The desl includes a set of intercepts which can be scanned in proper order to generate the chain for the given straight line.

A procedure is illustrated to reduce the number of classes of internal states to be considered in the state minimization problem for incompletely specified sequential machines. The procedure leads to an extension of the definition of prime compatibility classes of states. It is based on the updating of the logical closure constraints for prime classes due to previous eliminations of nonprime ones. An additional, more complex elimination mechanism is also presented.

A method is illustrated for the selection of a minimal cost subset of prime implicants of a Boolean function. The selection problem is represented by a table (P-table), which is an extension of a prime implicant table. A technique for P-table reduction is presented, which allows tabular simplifications for cyclic prime implicant tables also.

It is shown that, in minimizing an Incompletely specified flow table, nontrivial column reductions may be considered to obtain a low-cost sequential network. Compatibility classes of columns of a flow table are defined, and other basic concepts for a general approach to the problem are illustrated.

A method is illustrated for minimizing the number of internal states in incompletely specified sequential networks. The minimization algorithm applies to any type of incompletely specified flow table. It is shown that only some compatibility classes (prime compatibility classes) need be considered as members of a solution. The selection of prime classes may be obtained as the solution of an integer linear program or by tabular techniques that are an extension of those used in the selection of prime implicants.