Ackermann Function Research Articles

On the Ehrenfeucht–Mycielski sequence

We introduce the inverted prefix tries (a variation of suffix tries) as a convenient formalism for stating and proving properties of the Ehrenfeucht–Mycielski sequence [A. Ehrenfeucht, J. Mycielski, A pseudorandom sequence—how random is it? American Mathematical Monthly 99 (1992) 373-375]. We also prove an upper bound on the position in the sequence by which all strings of a given length will have appeared; our bound is given by the Ackermann function, which, in light of experimental data, may be a gross over-estimate. Still, it is the best explicitly known upper bound at the moment. Finally, we show how to compute the next bit in the sequence in a constant number of operations.

Fast Computation of Minimal Fill Inside A Given Elimination Ordering

Minimal elimination orderings were introduced by Rose, Tarjan, and Lueker in 1976, and during the last decade they have received increasing attention. Such orderings have important applications in several different fields, and they were first studied in connection with minimizing fill in sparse matrix computations. Rather than computing any minimal ordering, which might result in fill that is far from minimum, it is more desirable for practical applications to start from an ordering produced by a fill-reducing heuristic and then compute a minimal fill that is a subset of the fill produced by the given heuristic. This problem has been addressed previously, and there are several algorithms for solving it. The drawback of these algorithms is that either there is no theoretical bound given on their running time, although they might run fast in practice, or they have a good theoretical running time, but they have never been implemented, or they require a large machinery of complicated data structures to achieve the good theoretical time bound. In this paper, we present an algorithm called MCS-ETree for solving the mentioned problem in $O(nm A(m,n))$ time, where m and n are, respectively, the number of edges and vertices of the graph corresponding to the input sparse matrix and $A(m,n)$ is the very slowly growing inverse of Ackerman's function. A primary strength of MCS-ETree is its simplicity and its straightforward implementation details. We present run time test results to show that our algorithm is fast in practice. Thus our algorithm is the first that both has a provably good running time with easy implementation details and is fast in practice.

Kinetic maintenance of mobile [formula omitted]-centres on trees

Given a set P of points (clients) on a weighted tree T , a k -centre of P corresponds to a set of k points (facilities) on T such that the maximum graph distance between any client and its nearest facility is minimised. We consider the mobile k -centre problem on trees. Let C denote a set of n mobile clients, each of which follows a continuous trajectory on a weighted tree T . We establish tight bounds on the maximum relative velocity of the 1-centre and 2-centre of C . When each client in C moves with linear motion along a path on T , the motions of the corresponding 1-centre and 2-centre are piecewise linear; we derive a tight combinatorial bound of Θ ( n ) on the complexity of the motion of the 1-centre and corresponding bounds of O ( n 2 α ( n ) ) and Ω ( n 2 ) for a 2-centre, where α ( n ) denotes the inverse Ackermann function. We describe efficient algorithms for calculating the trajectories of the 1-centre and 2-centre of C : the 1-centre can be found in optimal time O ( n log n ) and a 2-centre can be found in time O ( n 2 log n ) . These algorithms lend themselves to implementation within the framework of kinetic data structures. Finally, we examine properties of the mobile 1-centre on graphs and describe an optimal unit-velocity 2-approximation.

Weak ε-nets and interval chains

We construct weak ε-nets of almost linear size for certain types of point sets. Specifically, for planar point sets in convex position we construct weak 1/r-nets of size O(rα(r)), where α(r) denotes the inverse Ackermann function. For point sets along the moment curve in ℝ d we construct weak 1/r-nets of size r · 2 poly(α(r)) , where the degree of the polynomial in the exponent depends (quadratically) on d. Our constructions result from a reduction to a new problem, which we call stabbing interval chains with j-tuples. Given the range of integers N = [1, n], an interval chain of length k is a sequence of k consecutive, disjoint, nonempty intervals contained in N. A j-tuple $\bar{P}$ = (p1,…,pj) is said to stab an interval chain C = I 1 …I k if each p i falls on a different interval of C. The problem is to construct a small-size family Z of j-tuples that stabs all k-interval chains in N. Let z (j) k (n) denote the minimum size of such a family Z. We derive almost-tight upper and lower bounds for z (j) k (n) for every fixed j; our bounds involve functions α m (n) of the inverse Ackermann hierarchy. Specifically, we show that for j = 3 we have z (3) k (n) = Θ(nα $\lfloor$k/2$\rfloor$ (n)) for all k ≥ 6. For each j≥4, we construct a pair of functions Pʹ j (m), Qʹ j (m), almost equal asymptotically, such that z (j) Pʹ j(m)(n) = O(nα m (n)) and z (j) Qʹ j(m)(n) = Ω(nα m (n)).

Classifying the phase transition threshold for Ackermannian functions

It is well known that the Ackermann function can be defined via diagonalization from an iteration hierarchy (of Grzegorczyk type) which is built on a start function like the successor function. In this paper we study for a given start function g iteration hierarchies with a sub-linear modulus h of iteration. In terms of g and h we classify the phase transition for the resulting diagonal function from being primitive recursive to being Ackermannian.

Invasion percolation through minimum-weight spanning trees

Invasion percolation is often used to simulate capillary-dominated drainage and imbibition in pore networks. More than a decade ago it was observed that the part of a pore network that is involved in an invasion bond percolation is a minimum-weight spanning tree of the network, where the weights indicate resistances associated with the bonds. Thus, one can determine a minimum-weight spanning tree first and then run the invasion bond percolation on the minimum-weight spanning tree. The time complexities of the two steps are O(malpha(m,n)) and O(n) , respectively, where m is the number of edges, n is the number of vertices, and alpha(,) denotes the inverse Ackermann function. In this paper we (1) formulate the property of minimum-weight spanning trees that justifies the two-step approach to invasion bond percolation, (2) extend the two-step approach to invasion site percolation, and (3) further extend it to simulations of drainage (imbibition) that include trapping of the wetting (nonwetting) phase. In case of imbibition we also take snap-off into account. As a consequence, all these simulations can now be done in O(malpha(m,n)) .

Exact and Approximate Truthful Mechanisms for the Shortest Paths Tree Problem

Let a communication network be modeled by an undirected graph G=(V,E) of n nodes and m edges, and assume that edges are controlled by selfish agents. In this paper we analyze the problem of designing a truthful mechanism for computing one of the most popular structures in communication networks, i.e., the single-source shortest paths tree. More precisely, we will study several realistic scenarios, in which each agent can own either a single or multiple edges of G. In particular, for the single-edge case, we will show that: (i) in the classic utilitarian case, the problem can be solved efficiently in O(mnlogα(m,n)) time, where ±(m,n) is the inverse of the Ackermanns function; (ii) in a meaningful non-utilitarian case, namely that in which agents valuation functions only depend on the edge lengths, the problem can be solved in O(m+nlogn) time. Conversely, for the multiple-edges case, we will show in the utilitarian case an O(mP+nPlogn) time truthful mechanism, where P=O(n) denotes the number of agents participating in the solution, while in the same non-utilitarian case we will prove a general lower bound to the approximation ratio that can be achieved by any truthful mechanism, by showing that no c-approximate mechanism can exist, for any fixed c < 5+√13 / 3+√13.

Unprovability of sharp versions of Friedman’s sine-principle

For every n ≥ 1 n\geq 1 and every function F F of one argument, we introduce the statement S P F n \mathrm {SP}_F^n : “for all m m , there is N N such that for any set A = { a 1 , a 2 , … , a N } A=\{a_1, a_2, \ldots , a_N\} of rational numbers, there is H ⊆ A H\subseteq A of size m m such that for any two n n -element subsets a i 1 &gt; a i 2 &gt; ⋯ &gt; a i n a_{i_1}&gt; a_{i_2}&gt;\cdots &gt; a_{i_n} and a i 1 &gt; a k 2 &gt; ⋯ &gt; a k n a_{i_1}&gt; a_{k_2}&gt; \cdots &gt; a_{k_n} in H H , we have \[ | sin ⁡ ( a i 1 ⋅ a i 2 ⋯ a i n ) − sin ⁡ ( a i 1 ⋅ a k 2 ⋯ a k n ) | &gt; F ( i 1 ) " . |\sin (a_{i_1}\cdot a_{i_2} \cdots a_{i_n}) - \sin (a_{i_1}\cdot a_{k_2} \cdots a_{k_n} )|&gt; F(i_1)". \] We prove that for n ≥ 2 n\geq 2 and any function F ( x ) F(x) eventually dominated by ( 2 3 ) log ( n − 1 ) ⁡ ( x ) ({2 \over 3})^{\log ^{(n-1)}(x)} , the principle S P F n + 1 \mathrm {SP}_F^{n+1} is not provable in I Σ n I\Sigma _n . In particular, the statement ∀ n S P ( 2 3 ) log ( n − 1 ) n \forall n \mathrm {SP}_{({2 \over 3})^{\log ^{(n-1)}}}^n is not provable in Peano Arithmetic. In dimension 2, the result is: I Σ 1 I\Sigma _1 does not prove S P F 2 \mathrm {SP}^2_F , where F ( x ) = ( 2 3 ) x A − 1 ( x ) F(x)=({2 \over 3})^{\sqrt [A^{-1}(x)]{x}} and A − 1 A^{-1} is the inverse of the Ackermann function.

Visibility maps of segments and triangles in 3D

Let T be a set of n triangles in three-dimensional space, let s be a line segment, and let t be a triangle, both disjoint from T. We consider the subdivision of T based on (in)visibility from s; this is the visibility map of the segment s with respect to T. The visibility map of the triangle t is defined analogously. We look at two different notions of visibility: strong (complete) visibility, and weak (partial) visibility. The trivial Ω ( n 2 ) lower bound for the combinatorial complexity of the strong visibility map of both s and t is almost tight: we prove an O ( n 2 α ( n ) ) upper bound for both structures, where α ( n ) is the extremely slowly increasing inverse Ackermann function. Furthermore, we prove that the weak visibility map of s has complexity Θ ( n 5 ) , and the weak visibility map of t has complexity Θ ( n 7 ) . If T is a polyhedral terrain, the complexity of the weak visibility map is Ω ( n 4 ) and O ( n 5 ) , both for a segment and a triangle. We also present efficient algorithms to compute all discussed structures.

Comparing Computational Power

It is common practice to compare the computational power of different models of computation. For example, the recursive functions are strictly more powerful than the primitive recursive functions, because the latter are a proper subset of the former (which includes Ackermann's function). Side-by-side with this “containment” method of measuring power, it is also standard to base comparisons on “simulation”. For example, one says that the (untyped) lambda calculus is as powerful—computationally speaking—as the partial recursive functions, because the lambda calculus can simulate all partial recursive functions by encoding the natural numbers as Church numerals.The problem is that unbridled use of these two distinct ways of comparing power allows one to show that some computational models (sets of partial functions) are strictly stronger than themselves! We argue that a better definition is that model A is strictly stronger than B if A can simulate B via some encoding, whereas B cannot simulate A under any encoding. We show that with this definition, too, the recursive functions are strictly stronger than the primitive recursive. We also prove that the recursive functions, partial recursive functions, and Turing machines are “complete”, in the sense that no injective encoding can make them equivalent to any “hypercomputational” model. 1

Melding priority queues

We show that any priority queue data structure that supports insert , delete , and find-min operations in pq ( n ) amortized time, where n is an upper bound on the number of elements in the priority queue, can be converted into a priority queue data structure that also supports fast meld operations with essentially no increase in the amortized cost of the other operations. More specifically, the new data structure supports insert , meld and find-min operations in O (1) amortized time, and delete operations in O ( pq ( n ) + α( n )) amortized time, where α( n ) is a functional inverse of the Ackermann function, and where n this time is the total number of operations performed on all the priority queues. The construction is very simple. The meldable priority queues are obtained by placing a nonmeldable priority queues at each node of a union-find data structure. We also show that when all keys are integers in the range [1, N ], we can replace n in the bound stated previously by min{ n , N }.Applying this result to the nonmeldable priority queue data structures obtained recently by Thorup [2002b] and by Han and Thorup [2002] we obtain meldable RAM priority queues with O (log log n ) amortized time per operation, or O (√log log n ) expected amortized time per operation, respectively. As a by-product, we obtain improved algorithms for the minimum directed spanning tree problem on graphs with integer edge weights, namely, a deterministic O ( m log log n )-time algorithm and a randomized O ( m √log log n )-time algorithm. For sparse enough graphs, these bounds improve on the O ( m + n log n ) running time of an algorithm by Gabow et al. [1986] that works for arbitrary edge weights.

Parameterized matching with mismatches

The problem of approximate parameterized string searching consists of finding, for a given text t = t 1 t 2 … t n and pattern p = p 1 p 2 … p m over respective alphabets Σ t and Σ p , the injection π i from Σ p to Σ t maximizing the number of matches between π i ( p ) and t i t i + 1 … t i + m − 1 ( i = 1 , 2 , … , n − m + 1 ) . We examine the special case where both strings are run-length encoded, and further restrict to the case where one of the alphabets is binary. For this case, we give a construction working in time O ( n + ( r p × r t ) α ( r t ) log ( r t ) ) , where r p and r t denote the number of runs in the corresponding encodings for y and x, respectively, and α is the inverse of the Ackermann's function.

An Inverse-Ackermann Type Lower Bound For Online Minimum Spanning Tree Verification*

Given a spanning tree T of some graph G, the problem of minimum spanning tree verification is to decide whether T = MST(G). A celebrated result of Komlos shows that this problem can be solved with a linear number of comparisons. Somewhat unexpectedly, MST verification turns out to be useful in actually computing minimum spanning trees from scratch. It is this application that has led some to wonder whether a more flexible version of MST verification could be used to derive a faster deterministic minimum spanning tree algorithm. In this paper we consider the online MST verification problem in which we are given a sequence of queries of the form “Is e in the MST of T ∪{e}?”, where the tree T is fixed. We prove that there are no linear-time solutions to the online MST verification problem, and in particular, that answering m queries requires Ω(mα(m,n)) time, where α(m,n) is the inverse-Ackermann function and n is the size of the tree. On the other hand, we show that if the weights of T are permuted randomly there is a simple data structure that preprocesses the tree in expected linear time and answers queries in constant time.

Minkowski Sums of Monotone and General Simple Polygons

Let P be a simple polygon with m edges, which is the disjoint union of k simple polygons, all monotone in a common direction u, and let Q be another simple polygon with n edges, which is the disjoint union of l simple polygons, all monotone in a common direction v. We show that the combinatorial complexity of the Minkowski sum P ź Q is O(klmnź(min{m,n})), where ź(·) is the inverse Ackermann function. Some structural properties of the case k = l = 1 have been (implicitly) studied in [17]. We rederive these properties using a different proof, apply them to obtain the above complexity bound for k = l = 1, obtain several additional properties of the sum for this special case, and then use them to derive the general bound.

Solving the 2-Disjoint Paths Problem in Nearly Linear Time

Given four distinct vertices s1,s2,t1, and t2 of a graph G, the 2-disjoint paths problem is to determine two disjoint paths, p1 from s1 to t1 and p2 from s2 to t2, if such paths exist. Disjoint can mean vertex- or edge-disjoint. Both, the edge- and the vertex-disjoint version of the problem, are NP-hard in the case of directed graphs. For undirected graphs, we show that the O(mn)-time algorithm of Shiloach can be modified to solve the 2-vertex-disjoint paths problem in only O(n + mα(m,n)) time, where m is the number of edges in G, n is the number of vertices in G, and where α denotes the inverse of the Ackermann function. Our result also improves the running time for the 2-edge-disjoint paths problem on undirected graphs as well as the running times for the 2-vertex- and the 2-edge-disjoint paths problem on dags.

Procedure placement using temporal-ordering information: Dealing with code size expansion

In a direct-mapped instruction cache, all instructions that have the same memory address modulo the cache size share a common and unique cache slot. Instruction cache conflicts can be partially handled at linked time by procedure placement. Pettis and Hansen give in [1] an algorithm that reorders procedures in memory by aggregating them in a greedy fashion. The Gloy and Smith algorithm [2] greatly decreases the number of conflict-misses but increases the code size by allowing gaps between procedures. The latter contains two main stages: the cache-placement phase assigns modulo addresses to minimizes cache-conflicts; the memory-placement phase assigns final memory addresses under the modulo placement constraints, and minimizes the code size expansion. In this paper: (1) we prove the NP-completeness of the cache-placement problem; (2) we provide an optimal algorithm to the memory-placement problem with complexity O(nmin(n,L)ack(n)) (n is the number of procedures, L the cache size, α is the inverse Ackermann's function that is lower than 4 in practice); (3) we take final program size into consideration during the cache-placement phase. Our modifications to the Gloy and Smith algorithm gives on average a code size expansion of 8% over the original program size, while the initial algorithm gave an expansion of 177%. The cache miss reduction is nearly the same as the Gloy and Smith solution with 35% cache miss reduction.

Facility location problems with uncertainty on the plane

We consider single facility location problems (1-median and weighted 1-center) on a plane with uncertain weights and coordinates of customers (demand points). Specifically, for each customer, only interval estimates for its weight and coordinates are known. It is required to find a “minmax regret” location, i.e. to minimize the worst-case loss in the objective function value that may occur because the decision is made without knowing the exact values of customers’ weights and coordinates that will get realized. We present an O ( n 2 log 2 n ) algorithm for the interval data minmax regret rectilinear 1-median problem and an O ( n log n ) algorithm for the interval data minmax regret rectilinear weighted 1-center problem. For the case of Euclidean distances, we consider uncertainty only in customers’ weights. We discuss possibilities of solving approximately the minmax regret Euclidean 1-median problem, and present an O ( n 2 2 α ( n ) log 2 n ) algorithm for solving the minmax regret Euclidean weighted 1-center problem, where α ( n ) is the inverse Ackermann function.

Repeated Angles in Three and Four Dimensions

We show that the maximum number of occurrences of a given angle in a set of n points in $\mathbb{R}^3$ is $O(n^{7/3})$ and that a right angle can actually occur $\Omega(n^{7/3})$ times. We then show that the maximum number of occurrences of any angle different from $\pi/2$ in a set of n points in $\mathbb{R}^4$ is $O(n^{5/2}\beta(n))$, where $\beta(n) = 2^{O(\alpha(n)^2)}$ and $\alpha(n)$ is the inverse Ackermann function.

Top-Down Analysis of Path Compression

We present a new analysis of the worst-case cost of path compression, which is an operation that is used in various well-known union-find algorithms. In contrast to previous analyses which are essentially based on bottom-up approaches, our method proceeds top-down, yielding recurrence relations from which the various bounds arise naturally. In particular the famous quasi-linear bound involving the inverse Ackermann function can be derived without having to introduce the Ackermann function itself.

A Shortest Path Algorithm for Real-Weighted Undirected Graphs

We present a new scheme for computing shortest paths on real-weighted undirected graphs in the fundamental comparison-addition model. In an efficient preprocessing phase our algorithm creates a linear-size structure that facilitates single-source shortest path computations in O(m log $\alpha$) time, where $\alpha$ = $\alpha$(m,n) is the very slowly growing inverse-Ackermann function, m the number of edges, and n the number of vertices. As special cases our algorithm implies new bounds on both the all-pairs and single-source shortest paths problems. We solve the all-pairs problem in O(mn log $\alpha$(m,n)) time and, if the ratio between the maximum and minimum edge lengths is bounded by n(log n)O(1) , we can solve the single-source problem in O(m + n log log n) time. Both these results are theoretical improvements over Dijkstra's algorithm, which was the previous best for real weighted undirected graphs. Our algorithm takes the hierarchy-based approach invented by Thorup.