Ackermann Function Research Articles

An analysis of Atkinson's algorithm

An algorithm for computing a minimal invariant partition of a permutation group due to Atkinson is analysed. The analysis shows the algorithm is O ( n 2 ), where n is the degree of the group. The leading coefficient is 3/2. Some suggested speed-ups are also analysed. The speed-ups imply that the cost of testing primitivity is O ( n 3 ), with a leading coefficent of 19/16.Careful use of linked lists to represent subsets of the partition leads to an O ( nlogn ) algorithm for computing a minimal invariant partition, and an O ( n 2 logn ) algorithm for testing primitivity. For both algorithms, the leading coefficient is 1.The use of trees to represent subsets, and the technique of path compression, lead to an O ( nG ( n )|S|) algorithm, where S is the set of generators for the group, and G (n) is a very slow growing function related to Ackermann's function, for computing the minimal invariant partition. The leading coefficient is such that, for degrees less than 1,000,000, the linked list version gives a smaller bound.

Superlinear bounds for matrix searching problems

Matrix searching in classes of totally monotone partial matrices has many applications in computer science, operations research, and other areas. This paper gives the first superlinear lower bound for matrix searching in classes of totally monotone partial matrices and also contains some new upper bounds for a class with applications in computational geometry and dynamic programming. The precise results of this paper are as follows. We show that any algorithm for finding row maxima or minima in totally monotone partial 2 n × n matrices with the property that the non-blank entries in each column form a contiguous segment, can be forced to evaluate Ω(nα(n)) entries of the matrix in order to find the row maxima or minima, where α( n) denotes the very slowly growing inverse of Ackermann's function. A similar result is obtained for n × 2 n matrices with contiguous non-blank segments in each row. The lower bounds are proved by introducing the concept of an independence set in a partial matrix and showing that any matrix searching algorithm for these types of partial matrices can be forced to evaluate every element in the independence set. A result involving lower bounds for Davenport-Schinzel sequences is then used to construct an independence set of size Ω(nα(n)) in the matrices of size 2 n × n and n × 2 n. We also give two algorithms to find row maxima and minima in totally monotone partial n × m matrices with the property that the non-blank entries in each column form a continuous segment ending at the bottom row. The first algorithm evaluates at most O( mα( n) + n) entries of the skyline matrix and performs at most that many comparisons, but may have O( mα( n)log log n + n) total running time. The second algorithm is simpler and has O( m log log n + n) total running time, but makes more comparisons, namely O( m log log n + n), than the first.

On-line dynamic programming with applications to the prediction of RNA secondary structure

An on-line problem is a problem where each input is available only after certain outputs have been calculated. The usual kind of problem, where all inputs are available at all times, is referred to as an off-line problem. We present an efficient algorithm for Waterman's problem, an on-line two-dimensional dynamic programming problem that is used for the prediction of RNA secondary structure. Our algorithm uses as a module an algorithm for solving a certain on-line one-dimensional dynamic programming problem. The time complexity of our algorithm is n times the complexity of the on-line one-dimensional dynamic programming problem. For the concave case, we present a linear time algorithm for on-line searching in totally monotone matrices which is a generalization of the on-line one-dimensional problem. This yields an optimal O( n 2) time algorithm for the on-line two-dimensional concave problem. The constants in the time complexity of this algorithm are fairly small, which make it practical. For the convex case, we use an O( nα( n)) time algorithm for the on-line one-dimensional problem, where α(·) is the functional inverse of Ackermann's function. This yields an O( n 2 α( n)) time algorithm for the on-line two-dimensional convex problem. Our techniques can be extended to solve the sparse version of Waterman's problem. We obtain an O(n + h log min{h, n 2 h }) time algorithm for the sparse concave case, and an O(n + hα(h)) log min{h, n 2 h }) time algorithm for the sparse convex case, where h is the number of possible base pairs in the RNA structure. All our algorithms improve on previously known algorithms.

VORONOI DIAGRAMS OF MOVING POINTS IN THE PLANE

In this paper, we consider the dynamic Voronoi diagram problem. In this problem, a given set of planar points are moving and our objective is to find the Voronoi diagram of these moving points at any time t. A preprocessing algorithm and a query processing algorithm are presented in this paper. Assume that the points are in k-motion, and it takes O(k) time to find roots of a polynomial with degree O(k). The preprocessing algorithm takes O(k2n3 log n · 2O(α(n)5k+1)) time to process moving functions of given points, and uses O(k2n32O(α(n)5k+1)) space to store the preprocessing result where α(n) is the functional inverse of Ackermann's function. The query processing algorithm is designed to report the Voronoi diagram of these points for a query time t. It takes O(n) time which is optimal.

THE COMPLEXITY OF COMPUTING PARTIAL SUMS OFF-LINE

Given an array A with n entries in an additive semigroup, and m intervals of the form Ii=[i,j], where 0<i<j≤n, we show that the computation of A[i]+⋯+A[j] for all Ii, requires Ω(n+mα(m,n)) semigroup additions. Here, α is the functional inverse of Ackermann's function. A matching upper bound has already been demonstrated.

Linear Circuits over $\operatorname{GF}(2)$

For $n=2^k $, let S be an $n \times n$ matrix whose rows and columns are indexed by $\operatorname{GF}(2)^k $ and, for $i, j \in \operatorname{GF}(2)^k , S_{i.j}=\langle i, j \rangle $, the standard inner product. Size-depth trade-oils are investigated for computing $S{\bf x}$ with circuits using only linear operations. In particular, linear size circuits with depth bounded by the inverse of an Ackerman function are constructed, and it is shown that depth two circuits require $\Omega (n \log n)$ size. The lower bound applies to any Hadamard matrix.

The complexity and construction of many faces in arrangements of lines and of segments

We show that the total number of edges ofm faces of an arrangement ofn lines in the plane isO(m2/3??n2/3+2?+n) for any?>0. The proof takes an algorithmic approach, that is, we describe an algorithm for the calculation of thesem faces and derive the upper bound from the analysis of the algorithm. The algorithm uses randomization and its expected time complexity isO(m2/3??n2/3+2? logn+n logn logm). If instead of lines we have an arrangement ofn line segments, then the maximum number of edges ofm faces isO(m2/3??n2/3+2?+n? (n) logm) for any?>0, where?(n) is the functional inverse of Ackermann's function. We give a (randomized) algorithm that produces these faces and takes expected timeO(m2/3??n2/3+2? log+n?(n) log2n logm).

Combinatorial complexity bounds for arrangements of curves and spheres

We present upper and lower bounds for extremal problems defined for arrangements of lines, circles, spheres, and alike. For example, we prove that the maximum number of edges boundingm cells in an arrangement ofn lines is ?(m2/3n2/3 +n), and that it isO(m2/3n2/3s(n) +n) forn unit-circles, wheres(n) (and laters(m, n)) is a function that depends on the inverse of Ackermann's function and grows extremely slowly. If we replace unit-circles by circles of arbitrary radii the upper bound goes up toO(m3/5n4/5s(n) +n). The same bounds (without thes(n)-terms) hold for the maximum sum of degrees ofm vertices. In the case of vertex degrees in arrangements of lines and of unit-circles our bounds match previous results, but our proofs are considerably simpler than the previous ones. The maximum sum of degrees ofm vertices in an arrangement ofn spheres in three dimensions isO(m4/7n9/7s(m, n) +n2), in general, andO(m3/4n3/4s(m, n) +n) if no three spheres intersect in a common circle. The latter bound implies that the maximum number of unit-distances amongm points in three dimensions isO(m3/2s(m)) which improves the best previous upper bound on this problem. Applications of our results to other distance problems are also given.

Finding the upper envelope of n line segments in O( n log n) time

It is known that the upper envelope of a set of n possibly-intersecting line segments in the plane has worst-case complexity Ō( nα( n)), where α( n) is the extremely slowly-growing inverse of Ackermann's function. We show how to compute the upper envelope of n line segments in optimal O( n log n) time. More generally, our method can be used to compute the upper envelope of “segments” that intersect pairwise at most k times. The upper envelope of such segments has worst-case complexity Ō(λ k + 2 ( n)), where λ s( n) is the maximum length of a Davenport-Schinzel sequence of order s on n symbol s; our method computes the upper envelope in O(λ k + 1 ( n)log n) time.

An almost linear Robinson unification algorithm

Further asymptotical improvement of original Robinson's unification idea is presented. By postponing the so-called occur-check in Corbin and Bidoit's quadratic rehabilitation of the Robinson algorithm at the end of unification an almost linear unification algorithm is obtained. In the worst case, the resulting algorithm has the time complexity O(p · A(p)), where p is the size of input terms and A is the inverse to the Ackermann function. Moreover, the practical experiments are summarized comparing Corbin and Bidoit's quadratic algorithm with the resulting almost linear unification algorithm based on Robinson's principle.

A note on the papadimitriou-silverberg algorithm for planning optimal piecewise-linear motion of a ladder

We present an improvement of a recent algorithm by Papadimitriou and Silverberg for optimal motion planning for a ladder (1987). The improved algorithm runs in time O( n 3α( n) log 2 n), where n is the number of obstacle edges and where α( n) is the extremely slowly growing inverse Ackermann function. This is an improvement by nearly θ( n) of the original algorithm of Papadimitriou and Silverberg.

The upper envelope of piecewise linear functions and the boundary of a region enclosed by convex plates: Combinatorial analysis

Letf1, ...,fmbe (partially defined) piecewise linear functions ofd variables whose graphs consist ofn d-simplices altogether. We show that the maximal number ofd-faces comprising the upper envelope (i.e., the pointwise maximum) of these functions isO(nd?(n)), where?(n) denotes the inverse of the Ackermann function, and that this bound is tight in the worst case. If, instead of the upper envelope, we consider any single connected componentC enclosed byn d-simplices (or, more generally, (d ? 1)-dimensional compact convex sets) in ?d+1, then we show that the overall combinatorial complexity of the boundary ofC is at mostO(nd+1??(d+1)) for some fixed constant?(d+1)>0.

Approximate minimum weight matching on points ink-dimensional space

We study the problem of finding a minimum weight complete matching in the complete graph on a set V ofn points ink-dimensional space. The points are the vertices of the graph and the weight of an edge between any two points is the distance between the points under someL q,-metric. We give anO((2c q )1.5k ɛ−1.5k (α(n, n))0.5 n 1.5(logn)2.5) algorithm for finding an almost minimum weight complete matching in such a graph, wherec q =6k 1/q for theL q -metric, α is the inverse Ackermann function, and ɛ ≤ 1. The weight of the complete matching obtained by our algorithm is guaranteed to be at most (1 + ɛ) times the weight of a minimum weight complete matching.

Visibility problems for polyhedral terrains

In this paper we study several problems concerning the visibility of a polyhedral terrain σ from a point (or several points) lying above it. Our results are: (1) For a fixed point a , one can preproeess a in time O ( n α( n ) log n ), to produce a data structure of size O( n α( n ) log n ), which supports fast ray shooting queries, where each such query asks for the point on σ that is visible from a in a specified direction. Here n is the number of faces of σ and α( n ) is the extremely slowly growing functional inverse of Ackermann's function. (2) If the viewing point a can vary along a fixed vertical line L , then the entire visibility structure of σ from L is of combinatorial complexity O ( n λ 4 ( n )), where λ 4 ( n ) is the maximal length of an ( n , 4) Davenport-Sehinzel sequence, and is nearly linear in n , and where the visibility structure in question is the decomposition of L x S 2 into maximal connected regions, such that for each such region R , all points ( a , u )∈ R are such that the ray from a ∈ L in direction u ∈ S 2 first intersects σ at a point on the same face of σ. Furthermore, we present an O ( n λ 4 ( n )log n )-time algorithm that preprocesses L and σ into a data-structure of size O ( n λ 4 ( n )) which supports O (log 2 n ) time ray shooting queries. (3) Concerning the results in (2) we show that (i) if L is not vertical, then the resulting visibility structure can be of size Ω( n 3 ); (ii) there exist a vertical line L and a polyhedral terrain a with n faces, for which the resulting visibility structure is of size Ω( n 2 α( n )). (4) Finally, we consider the problem of placing on the surface σ one or several viewing points which collectively cover the entire surface (i.e. each point on σ is visible from at least one of these viewing “stations”). We show (i) in the case of a single viewing station, one can determine in time O ( n log n ) whether such a station exists, and if so, produce such a point; (ii) the problem of finding the smallest number of points on σ that can collectively see the entire surface σ is NP -hard.

Minimum Spanning Trees in k-Dimensional Space

We study the problem of finding a minimum spanning tree in the complete graph on a set V of n points in k-dimensional space. The points are the vertices of this graph and the weight of an edge between two points is the distance between the points under some $L_q $ metric. We give an $O(\varepsilon ^{ - k} n\log n)$ algorithm for finding an approximate minimum spanning tree in such a graph; the weight of the approximate minimum spanning tree is guaranteed to be at most $(1 + \varepsilon )$ times the weight of a minimum spanning tree. We also present an algorithm to find a minimum spanning tree in the complete graph on V. Under the assumption that V consists of n random points, independently and uniformly distributed in the unit k-cube $[0,1]^k $, the expected running time of this minimum spanning tree algorithm is shown to be $O(n\alpha (cn,n))$ where c is a constant dependent on k and $\alpha $ is the inverse Ackermann function.

Separating two simple polygons by a sequence of translations

LetP andQ be two disjoint simple polygons havingm andn sides, respectively. We present an algorithm which determines whetherQ can be moved by a sequence of translations to a position sufficiently far fromP without colliding withP, and which produces such a motion if it exists. Our algorithm runs in timeO(mn?(mn) logm logn) where ?(k) is the extremely slowly growing inverse Ackermann's function. Since in the worst case Ω(mn) translations may be necessary to separateQ fromP, our algorithm is close to optimal.

Efficient handling of data structures in definitional languages

Implementations of operations on general data structures in definitional languages often lead to excessive copying and storage requirements. To partially overcome this problem, users are given facilities to select efficient storage structures or to guide storage allocation. This contradicts the spirit of definitional languages, requiring the user to get involved with implementation details.This paper presents a method for automatically recognizing excessive copying and optimizing the storage for data structures. Based on analysis of data dependencies, the storage may be reduced from an entire structure to individual elements of the structure. The benefits are especially significant in incremental structures, where only a constant number of elements of a large data structure is modified in each operation. For incremental structures, copying of unchanged parts of the structure is avoided, and unnecessary iterations are eliminated, without involving the user in this consideration. The user is thus relieved of considering the inefficiencies inherent in specifications in definitional languages. The method is applicable to a variety of language processors and computer architectures. The proposed optimization method produces better results than those obtained by explicit storage references.The paper describes the implementation of the method in the compiler of the MODEL definitional language. First, criteria are presented for recognizing structures that may be optimized. Then, a transformation that removes iterations implied by the operations on incremental structures is described. The method is exemplified by its application to the non-recursive iteration computation of the Ackermann's function.

An inherently iterative computation of ackermann's function

The Ackermann function is defined recursively by A(0,n)=n + 1; A(i,0) = A(i - 1, 1) for i>0; and A(i,n)=A(in −1, A(i-1))for i,n > 0. An iterative algorithm for computing A(i,n) is presented. It has O( i) space complexity and O( iA( i,n)) time complexity, both of which are much smaller than the corresponding quantities for an algorithm based directly on the recursive definition.

On the shortest paths between two convex polyhedra

The problem of computing the Euclidean shortest path between two points in three-dimensional space bounded by a collection of convex and disjoint polyhedral obstacles having n faces altogether is considered. This problem is known to be NP-hard and in exponential time for arbitrarily many obstacles; it can be solved in O ( n 2 log n ) time for a single convex polyhedral obstacle and in polynomial time for any fixed number of convex obstacles. In this paper Mount's technique is extended to the case of two convex polyhedral obstacles and an algorithm that solves this problem in time O ( n 3 · 2 O { α ( n ) 4 } log n ) (where α ( n ) is the functional inverse of Ackermann's function, and is thus extremely slowly growing) is presented, thus improving significantly Sharir's previous results for this special case. This result is achieved by constructing a new kind of Voronoi diagram, called peeper's Voronoi diagram , which is introduced and analyzed in this paper, and which may be of interest in its own right.

Planar realizations of nonlinear davenport-schinzel sequences by segments

LetG={l 1,...,l n } be a collection ofn segments in the plane, none of which is vertical. Viewing them as the graphs of partially defined linear functions ofx, letY G be their lower envelope (i.e., pointwise minimum).Y G is a piecewise linear function, whose graph consists of subsegments of the segmentsl i . Hart and Sharir [7] have shown thatY G consists of at mostO(nα(n)) segments (whereα(n) is the extremely slowly growing inverse Ackermann's function). We present here a construction of a setG ofn segments for whichY G consists ofΩ(nα(n)) subsegments, proving that the Hart-Sharir bound is tight in the worst case.Another interpretation of our result is in terms of Davenport-Schinzel sequences: the sequenceE G of indices of segments inG in the order in which they appear alongY G is a Davenport-Schinzel sequence of order 3, i.e., no two adjacent elements ofE G are equal andE G contains no subsequence of the forma ...b ...a ...b ...a. Hart and Sharir have shown that the maximal length of such a sequence composed ofn symbols is Θ(nα(n)). Our result shows that the lower bound construction of Hart and Sharir can be realized by the lower envelope ofn straight segments, thus settling one of the main open problems in this area.