Solving Nested Recursions With Trees. Abraham Isgur

Transcription

1 Solving Nested Recursions With Trees by Abraham Isgur A thesis submitted in conformity with the requirements for the degree of Doctor of Philosophy Graduate Department of Mathematics University of Toronto Copyright c 2012 by Abraham Isgur

2 Abstract Solving Nested Recursions With Trees Abraham Isgur Doctor of Philosophy Graduate Department of Mathematics University of Toronto 2012 This thesis concerns the use of labelled infinite trees to solve families of nested recursions of the form R(n) = k i=1 R(n a i p i j=1 R(n b ij)) + w, where a i is a nonnegative integer, w is any integer, and b ij, k, and p i are natural numbers. We show that the solutions to many families of such nested recursions have an intriguing combinatorial interpretation, namely, they count nodes on the bottom level of labelled infinite trees that correspond to the recursion. Furthermore, we show how the parameters defining these recursion families relate in a natural way to specific structural properties of the corresponding tree families. We introduce a general tree pruning methodology that we use to establish all the required tree-sequence correspondences. We then derive various properties (asymptotic results, frequency sequences, and efficient calculation algorithms) for the sequences by using the properties of the corresponding trees. ii

3 Dedication This thesis is dedicated to my grandmother, Carol Joyce Bergsagel. iii

4 Acknowledgements As this thesis represents the conclusion to several years of research, I have no small number of people to thank: First, my adviser, Professor Stephen Tanny, for first getting me interested in this area, and for advice, direction, and encouragement throughout the research process. In addition, for extensive help in the planning, organization, and editing of this thesis. Vitaly Kuznetsov for help producing many of the pictures appearing in this thesis. Professors Ed Barbeau and Eric Mendelsohn for their advice and feedback as this thesis took shape. Many people throughout the department who helped me navigate the thesis defense process, including Ida Bulat and Professor Joe Repka. Nigel Chan for creating Hofstadter, a computer program useful for calculating solution sequences and properties to nested recursions of the sort found in this thesis. Hofstadter can be downloaded from the web at All of the other mathematicians I have coauthored papers and collaborated on research with; this thesis wouldn t be what it is without the many things I learned by working with others. In roughly chronological order, thanks to David Reiss, Alejandro Erickson, Bradley Jackson, Frank Ruskey, Mustazee Rahman, Vitaly Kuznetsov, and Rafal Drabek. iv

5 Contents 1 Introduction Overview of Nested Recursions Properties of Solutions to Nested Recursions Highlights of the Tree Methodology Properties of Labelled Infinite Trees Outline The Basics: Trees, Sequences, and Pruning Overview The Labelled Binary Tree Solving the Recursion Consequences of the Tree Interpretation Recursion Parameters Determine the Structure of Trees Introduction A Two-Parameter Tree Family For R s,j (n) A Two-Parameter Tree Family For H s,j (n) Consistency in Parametrization Unifying Two 2-ary Order 1 Recursion Families Introduction v

6 4.2 Shifting In the Positive Direction Shifting in the Negative Direction Consequences of the Unified Tree Interpretation Higher Arity and Order Recursions and Their Trees Introduction ary Recursions of Order Greater than The k-ary Recursion and k-ary Trees The k-ary Ceiling Function Initial Conditions and Nonhomogeneous Recursions Tree Grafting The Grafted Tree Computing Terms of Solution Sequences to Nested Recursions 97 8 Summary, Conclusions, and Future Directions 101 Bibliography 106 vi

7 Chapter 1 Introduction 1.1 Overview of Nested Recursions In this thesis, all values of the parameters and variables are integers. This thesis concerns the use of infinite labelled trees to solve nested recursions (also called meta-fibonacci recursions). In the broadest possible sense, a nested recurrence relation is any recursion where some argument contains a term of the recursion 1 ; an early example, Hofstadter s Q, is defined by Q(n) = Q(n Q(n 1)) + Q(n Q(n 2)), with initial conditions Q(1) = Q(2) = 1. Our focus will be on solving the following type of nested recursion: R(n) = p k i R(n a i R(n b ij )) + w, (1.1) i=1 j=1 with some specified initial conditions, where a i and w are integers, and b ij, k, and p i are natural numbers. In almost all applications within this thesis, we have all p i equal to the same value, which we denote p and define to be the order of the recursion. We define the value of k as the arity of the recursion, and refer to a recursion with order k as k-ary. We refer to recursions of the form in (1.1) as generalized Conolly recursions 1 See [12] for a more formal approach to defining what qualifies as a nested recursion. 1

8 Chapter 1. Introduction 2 after the recursion C(n) = C(n C(n 1)) + C(n 1 C(n 2)), C(1) = 1, C(2) = 2, introduced by Conolly in [13]. This is the first nested recursion for which a combinatorial interpretation was found (Jackson and Ruskey,[28]); see Chapter 2 for additional details and discussion of this case. In recent years many special cases of (1.1), together with various sets of initial conditions, have been analyzed; see the references (in particular [2, 4, 8, 13, 14, 15, 16, 17, 20, 24, 25, 26, 27, 28, 33, 36, 38, 39]) for examples. These contributions illustrate that the solutions to particular cases of (1.1) can display a very wide range of behaviour. Some sequences, like Conolly s, are very well behaved with discernible and provable structure. Others, including the Hofstadter sequence, appear to be quite chaotic, but nonetheless display some evidence of structural regularities (see, for example, [32]). Still others are wild with no hint of any structure but nonetheless appear to remain well defined for all n (for example, the W -sequence originally defined by Hofstadter that is discussed in [3]). For any given set of parameters and initial conditions, solving the nested recursion (1.1) presents several unique challenges. First, it is often difficult to prove that the nested recursion with the given set of initial conditions actually defines an infinite solution sequence. The reason a given recursion might not do so is that, for some index n, one of the terms on the right hand side might have an argument that is not a positive integer less than n, at which point we could not evaluate the recursion and the solution sequence terminates ( dies ) 2. Furthermore, no simple resolution to this problem can exist: recently, Celeya and Ruskey ([11]) proved that there exists a nested recursion, namely, A(n) = A(n 4 A(A(n 4))) + 4A(A(n 4)) +A(2A(n 4 A(n 2)) + A(n 2)) 2 For an alternate approach, one can define R(n) = 1 for all n 0, preventing a recursion from dying. See Ruskey ([34]) for some interesting examples of the solution sequences this can yield. In some cases, interesting results arise from considering sequences that satisfy a recursion, even if they do not do so uniquely for a particular initial condition set. For example, in [23], the authors consider solutions to recursions that are not uniquely defined for any finite initial condition set.

9 Chapter 1. Introduction 3 for which the question of whether the recursion (given some particular initial condition set) defines a solution sequence is equivalent to the halting problem and thus undecidable. Even when considering only a particular initial condition set, the question of whether or not a given nested recursion defines a solution sequence is often nontrivial. For example, while Hofstadter s Q has been calculated up to a billion terms, no proof of the existence of an infinite solution sequence has been discovered. Although such substantial empirical evidence might be highly suggestive, it is by no means conclusive: we have identified examples of nested recursions that only become undefined after millions of terms. For example, the recursion R(n) = R(n 19 R(n 3)) + R(n 28 R(n 12)) with initial conditions R(1) = = R(29) = 1 becomes undefined only after more than 19 million terms. A second challenge is that the nesting structure of (1.1) makes these recursions resistant to the usual techniques used for solving (ordinary) difference equations, such as characteristic polynomials and generating functions. In some cases (see [17, 28] for examples) one can derive generating functions, difference sequences, and frequency sequences for a solution to the nested recursion, but only as a result of earlier analysis of the solution sequence. Lastly, the solution to a nested recursion can be highly sensitive to even small changes to either the initial conditions or the recursion parameters, which can produce a drastic change in the behaviour of the solution sequence. We illustrate this phenomenon in the course of our discussion in the following section. 1.2 Properties of Solutions to Nested Recursions We begin by presenting several examples highlighting the variety of possibilities for the behaviour of solution sequences to nested recursions. Consider first Hofstadter s Q, defined by Q(n) = Q(n Q(n 1)) + Q(n Q(n

10 Chapter 1. Introduction 4 2)), Q(1) = 1, Q(2) = 1. See Table 1.1 for a table of the first 100 values, and Figure 1.1 for a chart of the first 1000 values. The solution sequence appears very chaotic, and while it seems to have some patterns, essentially nothing has been proven about it - not even that it is well-defined for all n. The sequence Q(n) appears to have periods of chaotic behaviour followed by periods of tight convergence around n/2. Theorem below shows that if Q(n) does have the property that Q(n)/n converges to a nonzero limit L, then L = 1/2. The graph strongly suggests that this is the case, but no proof is known. Figure 1.1: A graph of the first 1000 values of the sequence generated by Q(n) with initial conditions 1, 1. On the other hand, if we give Q(n) the alternate initial conditions Q(1) = 3, Q(2) = 2, Q(3) = 1, we get a simple solution sequence given by Q(3k + 1) = 3, Q(3k + 2) = 3k + 2, Q(3k) = 3k 2 (see [18]) 3. 3 For even more about this sort of quasi-periodic behaviour that solutions to Hofstadter s recursion can exhibit, see [34].

11 Chapter 1. Introduction 5 Suppose that we slightly change the parameters of the recursion for Q(n) and instead consider the Conolly recursion, defined by C(n) = C(n C(n 1)) + C(n 1 C(n 2)), C(1) = 1, C(2) = 2. Judging by the closeness of the parameters, we might expect the behaviour of the solution to C(n) to be similar to that for Q(n), but in fact C(n) is orderly and well-behaved. Conolly ([13]) found that C(n) has a monotone nondecreasing solution sequence that hits every positive integer c with frequency φ(c) = ν 2 (c)+1, where the frequency φ(c) of c is the number of integers n with C(n) = c and where ν 2 (c) is the 2-adic valuation of c (the number of powers of 2 in the prime factorization of c). See Table 1.1 for the first 100 values of the solution to C(n). Next, shift the parameters of C(n), and consider T (n) = T (n 1 T (n 1)) + T (n 2 T (n 2)), now with three initial conditions T (1) = 1, T (2) = 1, T (3) = 2 (see [39] for more on T (n)). Again, we have made a small change, and this time the solution to the recursion remains almost unchanged: use Table 1.1 to compare the first 100 values of the solutions to T (n) and C(n). The only difference is that powers of 2 appear precisely one more time in the solution sequence to T (n). We will see the reason for this behaviour in Chapter 2. These last two solution sequences (to C(n) and T (n)) have the property that successive differences are always 0 or 1 (because the frequency of every natural number is positive). We call such a sequence slowly growing or slow. Many of the more tractable nested recursions have slow solutions. Because of the enormous variety of behaviours in the solution sequences to recursions of the form (1.1), slow solution sequences are a natural starting point for investigation and it is on such solutions that this thesis focuses. As the above discussion indicates, we can say very little in general about the behaviour of the solutions to nested recursions. There is, however, one highly useful result that works on any recursion of the form (1.1), first proved in [17] for the case w = 0.

12 Chapter 1. Introduction 6 n Q(n) C(n) T (n) n Q(n) C(n) T (n) n Q(n) C(n) T (n) n Q(n) C(n) T (n) Table 1.1: The first 100 values of Hofstadter s Q-sequence, Conolly s C-sequence, and Tanny s T -sequence.

13 Chapter 1. Introduction 7 Theorem Let A(n) be the solution sequence of a nested recursion of the form (1.1). Suppose that the ratio A(n)/n has a nonzero limit L. Then L = k 1 k i=1 p i. Proof. Let A(n) satisfy the recursion A(n) = ( k i=1 A n s i ) p i j=1 A(n a ij) + w. As a first step, we will show that we cannot have p i L > 1 for any i. Assume to the contrary that for some h, and for some ɛ > 0, p h L > 1 + ɛ. Then find some N such that for all j and for all n > N, A(n a hj ) > (1 + ɛ/2)(n a hj )/p h > n/p h + n ɛ 2p h 2a hj /p h. Then for n > N and n > max{ 4a hj }, p h ɛ j=1 A(n a hj ) > n n s h. But then the argument of the h th summand is negative, which is impossible since A(n) is a solution. Thus, for all i, p i L 1. We will later be able to show that, in fact, p i L < 1 for all i. Suppose there exists at least one value of i for which p i L = 1. Without loss of generality let p 1 L = 1. Since p 1 1, we have A(n) n L 1, so there exists some positive constant λ such that for all n, A(n) λn. Then for all n, A(n s 1 p1 j=1 A(n a 1j)) λ(n s 1 p 1 j=1 A(n a 1j)). It follows that A(n s p1 1 λ λs 1 /n λ p 1 A(n a 1j ) n j=1. But n n a 1j 1, so A(n a 1j) n that lim n A(n s 1 p 1 j=1 A(n a 1j)) n λ λ p 1 j=1 L = λ λp 1L = 0. Now, write A(n) n = A(n s 1 p1 j=1 A(n a 1j)) + n j=1 A(n a 1j)) n L, from which we deduce k i=2 (n A s i ) p i j=1 A(n a ij) + w and take the limit as n on both sides. The first term on the right vanishes. This argument shows that in evaluating L we can ignore any summands with index i such that p i L = 1. Further, it confirms that we cannot have p i L = 1 for all i, since then L = 0, which contradicts our assumption. Combining the above results we may safely assume that p i L < 1 for all i. For each i define κ i (n) := n s i p i j=1 A(n a ij). Then lim n κ i (n) n A(n) lim n κ i (n) =. But since lim n = L it follows that for all i, n ( A n s i ) p i j=1 A(n a ij) n s i p i j=1 A(n a ij) n = 1 p i L > 0, and thus

14 Chapter 1. Introduction 8 converges to L as n. We can write = A(n) n = k ( k n si p i i=1 i=1 j=1 A(n a ij) n ( A n s i ) p i j=1 A(n a ij) n + w n ) A (n s i p i j=1 A(n a ij) n s i p i j=1 A(n a ij) ) + w n. Taking the limit on both sides as n we get L = k i=1 (1 p il)(l), from which we conclude (since L > 0) that 1 = k L k i=1 p i, or L = k 1 k. i=1 p i Theorem implies that for unary nested recursions (those with k = 1), either A(n)/n does not tend to a limit or A(n)/n tends to 0. Note, however, that it is possible that A(n)/n converges to 0 for k > 1 in recursion (1.1), for example, the recursion R(n) = R(n R(n 1)) + R(n R(n 2)) 1 with initial conditions R(1) = R(2) = 1 has the solution sequence R(n) = 1. 4 Further, observe that we cannot remove the hypothesis that A(n)/n converges. To see this, consider the example discussed above of Q(n) = Q(n Q(n 1)) + Q(n Q(n 2)) with initial conditions Q(1) = 3, Q(2) = 2, Q(3) = 1. In this case, the ratio Q(n)/n splits into two infinite subsequences, one that tends to 1 and another that tends to 0. Note that neither subsequence approaches 1/2 as the above theorem would otherwise predict. It also makes sense to ask whether Theorem only applies to solutions that are well-defined according to our criteria, that is, whether it would still hold for solution sequences where we permit arguments that are greater than n or less than 1. In fact, it does not apply: consider the recursion R(n) = R(n R(n)) + R(n 1 R(n)), with the solution sequence R(n) = n for n 0 and R(n) = n/2 for n < 0. 4 It remains an open question whether a nontrivial counterexample exists for homogeneous nested recursions.

15 Chapter 1. Introduction 9 For the families of nested recursions we study, our tree methodology provides a remedy for the difficulty of deriving asymptotic results. We will be able not only to prove that the solutions tend towards the predicted limit (k 1)/ k i=1 p i, but also to derive bounds on how close the convergence is. 1.3 Highlights of the Tree Methodology In [28], the authors introduce a combinatorial interpretation in terms of labelled infinite binary trees for the solutions to an infinite family of recursions containing C(n) and T (n) that fully explains their behaviour. Further, this interpretation makes clear why, in this case, the small changes in the parameters that distinguish the recursions for C(n) and T (n) lead to only a small change in their respective solution sequences. The goal of this thesis is to show how to generalize, unify and extend this combinatorial interpretation in order to apply it to solve a variety of much broader classes of nested recursions of the form (1.1), including some with nonslow solution sequences. In so doing we develop a more broadly applicable solution methodology for this type of nested recursion. The central idea of the solution method we present is to show that families of recursions of the form (1.1) count the leaves (or some variant thereof) on a labelled tree. In particular, we will show that the parameters that define recursion families determine structural properties of the corresponding tree. For example, if the variable k ( arity ) in recursion (1.1) is 2, the tree is binary, if k = 3, the tree is ternary, and so on. A brief example follows: the unary recursion g 2 (n) = g 2 (n 2 g 2 (n 1)) + 1 with initial conditions g 2 (1) = g 2 (2) = g 2 (3) = 1 has solution L G (n), the number of leaves with label less than or equal to n on the tree G 2 (n) in Figure For example, there 5 The recursions belonging to the one-parameter family g s (n) = g s (n g s (n 1)) + 1 are among the fairly few nested recursions with a simple closed form solution: 8(n+( s+1 2 )) See [25] for a derivation using trees.

16 Chapter 1. Introduction 10 are 2 leaves with label less than or equal to 7, so g 2 (7) = 2. We will see where this tree comes from in Chapter 6. Figure 1.2: The tree G 2 (13). Note that the number of leaves, 4, is the same as the value of g 2 (13) in the recursion g 2 (n) = g 2 (n 2 g 2 (n 1)) + 1 with initial conditions g 2 (1) = g 2 (2) = g 2 (3) = Properties of Labelled Infinite Trees We now briefly discuss the properties and uses of labelled infinite trees - in particular, the type appearing in this paper. Labelled binary trees (such as the ones which the Conolly sequence corresponds to; see Chapter 2) are a widely-used structure for encoding or storing data. One of the reasons for their use is the ability to define systematic tree traversal methods. The traversal we will use throughout this thesis to apply labels to our trees is preorder, defined as the unique traversal that meets the following criteria 6 : (i) The subtree descending from a node s i th child is fully traversed before reaching that node s (i + 1) st child. 6 Note that we concern ourselves in this thesis (and definition) only with up-infinite trees, that is, those that have leaves and extend infinitely far upwards, rather than the traditional finite rooted trees to which preorder normally applies.

17 Chapter 1. Introduction 11 (ii) A node is traversed before any of its descendants, unless that node is on the extreme left (meaning that it and all of its ancestors are left children). (iii) Nodes that are on the extreme left are traversed as soon as the subtree descending from their left child is fully traversed (the extreme left leaf node is the first to be traversed in preorder). See Figure 1.3 for an example of the preordering of an up-infinite tree. Figure 1.3: Preorder traversal of a labelled infinite tree. Note that this differs from the standard preorder traversal of the finite rooted subtree consisting of only the nodes and edges shown in this picture. A second reason for the common use of labelled binary trees is that we can quickly locate a particular label in time proportional to the tree s height, a fact which we will use when developing an algorithm for efficiently calculating values of solution sequences using the corresponding tree. Although the trees in this thesis are not always binary, the basic properties that make binary tree searches efficient extend with some corrections. Similarly, translating data into trees is a common technique for improving the time complexity of calculations. One example is calculating properties of a cograph (such as

18 Chapter 1. Introduction 12 maximum clique, maximum independant set, or vertex coloring number) by translating it into a corresponding cotree and then calculating from the bottom up (see, for example, [37]). Another application, for graphs with bounded treewidth, is to find the tree decomposition of the graph. The tree decomposition can then be used to efficiently solve various graph problems; for an overview of this technique, see [7]. Examples of problems that can be handled in this fashion include encoding or decoding the graph in linear time (see [10]), deciding if the graph is 3-colorable in linear time, locating the set of mutually disjoint paths between specified vertices in linear time, and solving various optimization problems on graphs (see [7] for further examples and discussion). It should be no surprise that many interesting results follow quickly once we prove that we can identify solution sequences to nested recursions with trees. For example, we show in Section 4.4 that given a number, we can calculate the frequency with which it occurs in the solution sequence of a nested recurrence by calculating the height of the first common ancestor a particular leaf and the succeeding leaf. We derive optimal asymptotic results by showing that the error term between R(n) and its asymptote is bounded by a constant multiple of the tree s height. Using the tree interpretation, we develop an algorithm for calculating values of R(n) in O(log k (n)) worst-case time and space complexity (versus Θ(n) for direct computation from the recursion). The central idea of the algorithm is to locate the shortest path from the highest-level nonempty node to the node containing n, and then associate each branch in the path with the correct amount of leaves to the left of it. See Chapter 7 for the details. We now briefly discuss some connections between labelled trees of the type used in this thesis and other mathematical objects. First, we consider a connection to binary compact codes found by Jackson and Ruskey [28]. A binary compact code (of order q) is a sequence (c 1, c 2,..., c q ) of nonincreasing natural numbers such that q i=1 2 c i = 1.

19 Chapter 1. Introduction 13 Binary compact codes relate to extended binary trees (a rooted tree such that each node has either two children or no children) whose leaves, going from left to right, have nondecreasing level. To see this connection, take an extended binary tree, label the root 0, and label every child one higher than its parent. For example, on a complete height 2 extended binary tree, the root would be labelled 0, the two second-level nodes would be labelled 1, and the four leaves would be labelled 2. Then the compact code is the sequence of leaf labels from left to right. An extremal binary compact code of order q and height h is one with c 1 = h, such that no other binary compact code of order q has more repetitions of h. For example, the code (2, 2, 2, 2) is an extremal binary compact code of order 4 and height 2, and the code (3, 3, 3, 3, 1) is an extremal binary compact code of order 5 and height 3. Clearly, extremal binary compact codes correspond to binary trees with the maximum possible number of leaves on the lowest level, where q is the total number of leaves, and h is the height of the tree (ie, the length of the longest path from the root to a leaf); we call such trees optimal. In fact, optimal trees correspond to the subtree of an infinite binary tree that is labeled in preorder (as defined above). In [28], the authors produce an algorithm for creating optimal trees, and show that the maximum number of bottom-level leaf pairs on any binary tree with q leaves is T (q 1), where T is the solution to the Tanny recursion T (n) = T (n 1 T (n 1)) + T (n 2 T (n 2)), discussed above, with initial conditions T (1) = T (2) = 1, T (3) = 2. Another link to labelled binary trees is the connected isoperimetric problem (see [35, 6]). For any graph G = (V, E) and a vertex subset S V, the vertex boundary of S is all vertices of G with distance (in G) of exactly 1 from S, and the edge boundary of S is the set of all edges in E between a vertex in S and a vertex in V \S. The vertex (edge) isoperimetric problem at some natural number i is to determine the smallest possible size for the vertex (edge) boundary over all possible choices of S with S = i, and the

20 Chapter 1. Introduction 14 connected isoperimetric problem is the same, but with the restriction that S induces a connected subgraph of G. For the connected isoperimetric problem on a tree, the answers to the vertex and edge versions are equal (so we just refer to it as the connected isoperimetric problem). The authors in [6] consider the connected isoperimetric problem on an infinite complete binary tree (of the sort used in this paper, with infinitely many leaves and extending infinitely far up). They show that the answer to the connected isoperimetric problem at i on such a tree is i + 2 2T (i), where T (n) is the solution to the Tanny recursion discussed above. We conclude this section with a connection, discovered by Kubo and Vakil in [29], between the solution to the Conway recursion a(n) = a(a(n 1)) + a(n a(n 1)), with initial conditions a(1) = a(2) = 1, and a labelled tree of a different sort than the ones used in this thesis. Note that the Conway recursion is not of the form (1.1). Consider the set of all finite sets of natural numbers, totally ordered as follows: {} is minimal, and other sets are ordered by largest element, then by cardinality, and then by second largest element, third largest element, and so on. Thus, {4, 2} > {3, 2, 1} (because 4 > 3), {7, 4, 3, 2, 1} > {7, 6, 5} (because both have the same largest element, but the set on the left has higher cardinality), and {6, 5, 4, 1} > {6, 5, 3, 2} (since both sets have the same largest element, same cardinality, and same second-largest element, but the set on the left has the larger third-largest element). Let b i be the i th such set, so that b 1 = {}, b 2 = {1}, and so on. Define the compression operator S on these sets as follows: first, let S({}) = S({1}) = {}. For n > 1, let S({n}) = {n 1}, and for any set X with two or more elements, let S(X) be the set given by removing the smallest element of X, and then subtracting 1 from every other element.

21 Chapter 1. Introduction 15 We can order these sets into a rooted tree by using the compression operator: label the root of a tree {}, and then a node labelled with X has a child labelled with Y if and only if S(Y ) = X. Note that this tree is in a sense reversed from the trees we consider in the rest of this thesis: rather than an infinite tree with leaves but no root, it is an infinite tree with a root but no leaves. The authors of [29] show the following connection to the Conway sequence a(n): the compression of the n th set is the a(n) th set, or in other words S(b n ) = b a(n). 1.5 Outline We begin in Chapter 2 by introducing the general methodology (the pruning argument) that establishes the correspondence between solutions to nested recursions and infinite labelled trees, together with the terminology used throughout this thesis. As an illustrative example, we apply our solution methodology to solve the 2-ary one-parameter nested recursion family R s (n) = R s (n s R s (n 1)) + R s (n s 1 R s (n 2)) (1.2) with initial conditions R s (1) = R s (2) = = R s (s + 1) = 1, R s (s + 2) = 2. This family, first solved in [28], is an obvious generalization of the Conolly recursion (the special case s = 0) mentioned above. It provides a relatively simple example of a parametrized family - in this case, the only parameter is s - and we illustrate how changing the value of s modifies the tree used in the combinatorial interpretation. In Chapter 3, we apply our methodology to solve the nested recursion families R s,j (n) = R s,j (n s R s,j (n j)) + R s,j (n s j R s,j (n 2j)) (1.3) and H s,j (n) = H s,j (n s H s,j (n j)) + H s,j (n s 2j H s,j (n 3j)), (1.4)

22 Chapter 1. Introduction 16 a pair of two-parameter families. Note that when j = 1, (1.3) covers (1.2) as a special case. In particular, we focus on identifying patterns in how a given parameter affects the tree in consistent ways across multiple recursion families. In Chapter 4, we apply our methodology to solve two new, even more general nested recursion families which include, as special cases, the families discussed in Chapter 3. These two families are R s,j,m (n) = R s,j,m (n s R s,j,m (n j))+r s,j,m (n s j m R s,j,m (n 2j m)) (1.5) and R s,j, q (n) = R s,j, q (n s R s,j, q (n j)) + R s,j, q (n s j R s,j, q (n 2j + q)), (1.6) with s a nonnegative integer, j a natural number, and m and q integers with 0 m j and 0 q j. Note that when m = 0 and q = 0, (1.5) and (1.6) are the same and are also identical to (1.3); we may think of (1.5) as moving the recursion parameters of the second summand in the positive direction and (1.6) as moving them in the negative direction. Furthermore, when m = j we have (1.4). Thus, the recursion family (1.5) contains the previously known tree interpretations as special cases, and also contains all of the intermediate recursions lying between the two previously unconnected recursion families. We demonstrate the versatility of our methodology in Chapter 5, where we apply it to solve several recursions of the form (1.1) that lie outside the scope of the families (1.5) and (1.6) because they have parameters k > 2 or p > 1 (or both). In Section 5.2, we discuss the variants of recursion (1.3) that arise with k = 2, p > 1 in equation (1.1), obtaining a small extension of results first identified in [17]. In Section 5.3, we discuss the combinatorial interpretation for the version of the recursion (1.3) with p = 1 and k > 2. Finally, in Section 5.4 we conclude with a major new combinatorial interpretation for a generalization of recursion (1.4) with both k > 2 and p > 1.

23 Chapter 1. Introduction 17 A drawback of the tree methodology presented up to this point is that the tree can only be used to solve the corresponding recursion for a particular set of initial conditions defined by the tree structure and labelling. In Chapter 6, we discuss a way to overcome this limitation by grafting finite trees into a tree interpretation, which allows us to solve recursions with different initial condition sets. In addition, this same result allows us to solve some nested recursions with a constant nonhomogeneous term by grafting onto the tree for the related homogeneous equation. With all the tree interpretations established, in Chapter 7 we discuss an algorithm for computing specific values of a solution sequence by leveraging the properties of trees as data structures. We prove that this algorithm has worst-case time complexity and space complexity O(log k (n)) (compared to Θ(n) for both for calculating directly from the definition of a nested recursion). We conclude in Chapter 8 with a summary of the known results about tree interpretations. We also provide some thoughts about the future direction of research in this emerging new field. We summarize the sources of the material presented: all the material in Chapters 4 and 7, as well as in Section 5.4, appears here for the first time; Theorem in Section 5.2 is a small extension of a result first appearing in [17] (where only the s = 0 case was considered). The results in Chapter 2 were discovered by Jackson and Ruskey [28], although we have modified the proofs; all the other material in this thesis first appeared in collaborations with various coauthors (see the references in each section for details). The pruning technique applied throughout this thesis, including to the modified proofs in Chapter 2, is new; it unifies and systematizes the various approaches to pruning described in earlier papers that used this technique, while at the same time retaining the spirit of the earlier proofs.

24 Chapter 2 The Basics: Trees, Sequences, and Pruning 2.1 Overview In this section, we present the basic, original tree interpretation (first described in [28]) for solving the nested recursion family (which we assign a new equation number here for convenience) R s (n) = R s (n s R(n 1)) + R s (n s 1 R s (n 2)), R s (1) = R s (2)... = R s (s + 1) = 1, R(s + 2) = 2. (2.1) Since k = 2 and p = 1 here, we refer to recursion (2.1) as a 2-ary, order 1 recursion. Where it won t cause confusion, we omit the subscript s. The case s = 0 was first studied by Conolly in [13], while the case s = 1 was solved in [39]. All of the results in this section are in fact special cases of the new results in Chapter 4, but we present them in order to provide context and also to illustrate our new solution techniques, which can become very complicated when applied to more general recursion families containing many more parameters. 18

25 Chapter 2. The Basics: Trees, Sequences, and Pruning 19 Throughout what follows in this chapter, we use a running example with s = 2 and n = 31 to aid in the explication of our approach. 2.2 The Labelled Binary Tree For s, n natural numbers, we define the tree T s (n) (or T (n) when it won t cause confusion to omit the subscript) with an infinite number of nodes and a finite number n of labels, as follows. First, draw an infinite binary tree in preorder (that is, from the bottom left). All nodes on the extreme left except the very first node on the bottom left are supernodes. All nodes on the bottom level of T (n) (including the bottom leftmost node) are leaves. Any other node is a regular node. Place the natural numbers 1 through n into the nodes of T (n) in preorder as labels, with one label going into each regular node and leaf, and s labels going into each supernode. Note that if n is a label on a supernode, that supernode might be only partly full (for example, if s = 4, and n = 3, we place the label 1 on the bottom left node, and 2 and 3 on the first supernode, leaving the first supernode only partly full). See Figure 2.1 for our running example with s = 2 and n = 31. Figure 2.1: The tree T 2 (31), corresponding to the value of R 2 (31) = 13 in the solution sequence to the recursion (2.1).

26 Chapter 2. The Basics: Trees, Sequences, and Pruning 20 As is standard in graph theory, we use genealogical terminology to characterize certain of the nodes in the tree. A node is the child of its parent if the child is one level below the parent and they are connected by an edge. A node is a descendant of its ancestor if the descendant is l levels below the ancestor and connected by l edges. Nodes are siblings if they share the same parent (for example, in Figure 2.1, the node containing 8 and the node containing 9, the two children of the node containing 7, are siblings). In addition, we require some less common (but frequently used in this area, see for example [27]) terminology. Penultimate nodes are nodes whose children are both leaves. We will often need to distinguish between what we call left and right nodes: a left node (for example, the one containing 8 in Figure 2.1) is the left child of its parent (the node containing 7), and correspondingly a right node (such as the node containing 9) is the right child of its parent. A node is empty if it has no labels, and full if it has the maximum possible number of labels it can hold (note that, in this construction, leaves and regular nodes are either empty or full, but supernodes might be only partly full). When we want to refer to the unlabelled tree (that is, T (n) without regard to the number or placement of labels), we call it the skeleton. Define the leaf counting function L T (n) to be the number of nonempty leaves in T (n). For example, in Figure 2.1, we have L T2 (31) = 13 and L T2 (12) = 4. Observe that R 2 (31) = 13 and R 2 (12) = 4. In the next section, we show that this relationship holds for all n, that is, L T (n) solves the recursion (2.1). 2.3 Solving the Recursion The following proof that L T (n) solves recursion (2.1) relies on the same basic ideas as the original proof in [28], but uses different terminology and organization. We insert it here to provide an illustration of our methodology in a simple case, so as familiarize the

27 Chapter 2. The Basics: Trees, Sequences, and Pruning 21 reader with the major ideas before approaching the more complex recursions that we solve later (particularly those in Chapter 4) that contain more than one parameter. First observe that by definition L T (n) obviously satisfies the initial conditions of recursion (2.1), since L T (1) =... = L T (s + 1) = 1, L T (s + 2) = 2. Next we must establish that for n > s + 2, the leaf counting function satisfies L T (n) = L T (n s L T (n 1)) + L T (n s 1 L T (n 2)). To accomplish this, we show that the first and second summands each count particular subsets of the nonempty leaves on L T (n): there are L T (n s L T (n 1)) nonempty left leaves on T (n), and L T (n s 1 L T (n 2)) nonempty right leaves on T (n). The main tool for establishing this correspondence is the pruning technique. To show that L T (n s L T (n 1)) counts the nonempty left leaves of T (n), we first note that L T (n s L T (n 1)) is the number of leaves on the tree T (n s L T (n 1)). We show how to prune the tree T (n), transforming it into the tree T (n) which we show is just T (n s L T (n 1)). Let L T (n) count the number of nonempty leaves of T (n). The main idea is to interpret the subtraction of L T (n 1) in the argument as removing ( pruning ) the leaves of T (n), and to note that an infinite binary tree with the bottom level cut off is still an infinite binary tree. Then, we argue that a penultimate node of T (n) ends the pruning operation as a nonempty leaf of T (n) if and only if its left child in T (n) was nonempty. To begin, we define the pruning operation that will construct T (n s L T (n 1)) = T (n) out of T (n), for n s + 2 (note that this requirement means that at least both children of the first supernode are full). The steps are as follows, and are illustrated in our running example in Figures 2.2, 2.3, 2.4, and 2.5. Deletion step : delete all leaf labels in T (n) less than or equal to n 1 (that is, delete all leaf labels, except n if n is a leaf label). This deletes L T (n 1) labels. Initial correction step : note that since n s + 2 and the last label on the first

28 Chapter 2. The Basics: Trees, Sequences, and Pruning 22 Figure 2.2: In the deletion step for T 2 (31), all leaf labels other than 31 are deleted. The deleted labels are indicated in red. supernode (for s 0) is s + 1, the first supernode contains its full complement of s labels. Delete all s labels from the first supernode. (Note: in later applications, some pruning operations will have an end correction step as well, but this example does not.) Lifting step : Move the label n (regardless of where on the tree it is located) from its current node into the first supernode. Since we have deleted all the leaf labels less than n, and moved n into the first supernode, all the leaves are empty. As the last part of the lifting step, delete the leaves. The original penultimate nodes of T (n) (including the first supernode) become the leaves of the new pruned tree. The resulting tree clearly has the same skeleton as T (n), just less labels - specifically, it has n s L T (n 1) labels. Relabelling step : rename the existing n s L T (n 1) labels in preorder from 1 to n s L T (n 1). The resulting tree is T (n) = T (n s L T (n 1)). We prove the following key lemma:

29 Chapter 2. The Basics: Trees, Sequences, and Pruning 23 Figure 2.3: In the initial correction step for T 2 (31), the labels 2 and 3 are deleted from the first supernode. Lemma Let n s + 2, and let X be a penultimate level node of T (n). Then X is nonempty in T (n) if and only if the left child of X is nonempty in T (n). Proof. Recall that penultimate level nodes of T (n) become leaf nodes of T (n) during the lifting step. First, suppose that X is the first supernode. Since the left child of X is the first node of T (n), it must be full. Further, since n s + 2 and the last label on the first supernode (for s 0) is s + 1, the label n is not in the first supernode so is not deleted during the initial correction step. Thus, the label n will be moved into X during the lifting step and therefore X will be nonempty in T (n). Now suppose that X is not the first supernode (meaning it must be a regular node). Case 1: the node X and its left child are both empty in T (n). No step will put labels into any nodes other than the first supernode, so X will end the pruning process empty in T (n), as desired. Case 2: the node X is nonempty in T (n), but its left child is empty in T (n). This means that n is the single label in X in T (n), and will be moved out during the lifting step, leaving X empty in T (n). Case 3: the node X and its left child are both nonempty in T (n). The only step that

30 Chapter 2. The Basics: Trees, Sequences, and Pruning 24 Figure 2.4: In the lifting step for T 2 (31), 31 moves into the first supernode (which becomes a leaf). All of the leaves of T 2 (31) are empty and are deleted. can move labels out of penultimate level nodes (other than the first supernode) is the lifting step. Since X has a nonempty left child, the label on X is smaller than n. Thus, the label on X won t be removed by any step in the pruning process and so X will end the pruning process with a label, making it nonempty in T (n) as desired. Using the above lemma, we derive the desired result of this chapter: Theorem The leaf counting sequence L T (n) solves the recursion (2.1). Proof. We know that the s + 2 initial conditions of the recursion match L T (n), so we need to simply check that the recursion holds for R(n) = L T (n) when n s + 3, that is, we want to show L T (n) = L T (n s L T (n 1)) + L T (n s 1 L T (n 2)). By definition, the left-hand side is the total number of nonempty leaf nodes in T (n). By Lemma 2.3.1, we know that the first summand on the right-hand side is the number of nonempty left leaf nodes in T (n). Finally, note that the second summand on the right is in fact L T (n 1), the number of nonempty left leaf nodes in T (n 1). We prove that this is the same as the number of nonempty right leaf nodes in T (n). First, suppose that n is not on a left leaf node in T (n). Then the number of nonempty left leaf nodes is equal to the number of nonempty right leaf nodes (because if not, there

31 Chapter 2. The Basics: Trees, Sequences, and Pruning 25 Figure 2.5: In the relabelling step for T 2 (31), the 17 remaining labels are replaced with 1 through 17, showing that T 2 (31) = T 2 (17). would be a last left leaf node containing n whose sibling was empty). Also, since n is not in a left leaf node, the number of nonempty left leaf nodes in T (n) is the same as the number of nonempty left leaf nodes in T (n 1), so in this case, L T (n 1) is indeed the number of nonempty right leaf nodes in T (n). Now suppose that n is on a left leaf node in T (n). In this case there will be one more nonempty left leaf node than right leaf node, and correspondingly the number of nonempty left leaf nodes in T (n 1) is exactly one less than the number of nonempty left leaf nodes in T (n) (because going from n to n 1 empties the node with n). This proves the theorem. 2.4 Consequences of the Tree Interpretation Now that we have proven the combinatorial interpretation for recursion (2.1), we derive several results from it. First, recall that Theorem states that if a solution to recursion (2.1) has the property that R(n)/n converges, it converges to either 0 or 1/2. However, Theorem does not guarantee convergence: the ratio R(n)/n may fail to converge at all. By using the tree interpretation, we can immediately see that R(n)/n converges to 1/2, since

32 Chapter 2. The Basics: Trees, Sequences, and Pruning 26 approximately half the nodes of a binary tree are on the bottom level. In fact, we can do better: Theorem The solution sequence to recursion (2.1) satisfies R(n) = n/2+o(log 2 (n). Proof. First, consider the special case when s = 1. Observe that when n = 2 a, that is, when n is the label on the a th supernode, then the nonempty nodes are a complete binary tree with a levels plus one label on the a th supernode, and thus there are 2 a 1 nonempty leaves. Thus, we have R(2a ) 2 a = 2a 1 2 a = 1/2. In the general case, the largest differences (n/2 R(n))/n will occur when n is the label on the penultimate node right before the first leaf after a supernode, because these are the places where the most labels occur between leaf nodes - for example, if n = 23 in Figure 2.1. When this occurs, n = 2 a + (a 1) + a(s 1): the a 1 term accounts for the a 1 nodes after the a th supernode and before its first leaf descendant (the ones containing 21,22,and 23 in Figure 2.1), and the a(s 1) corrects our count of the labels in the labels in the first a supernodes from the one label per supernode we assumed earlier. The largest differences (R(n) n/2)/n will occur when n is the last label before a supernode, that is, exactly s + (a 1) labels before the above case. This means the furthest differences (R(n) n/2)/n occur at R(2a +(a 1)+a(s 1)) (2 a +(a 1)+a(s 1)) = 2 a 1 or R(2a +a(s 1) s) 2 = a 1. Therefore, since a grows at O(log (2 a +(a 1)+a(s 1)) (2 a +a(s 1) s) (2 a +a(s 1) s) 2(n)) and the smaller terms are linear in a, we can see that R(n) = n/2 + O(log 2 (n)). We can also apply our combinatorial interpretation to derive a frequency sequence for the solution; recall that the frequency sequence of R(n) is the sequence φ(c) = R 1 (c), or in other words, the frequency of c is the number of values of n with R(n) = c. As an example, since the solution to R 0 (s) begins with R(1) = 1, R(2) = 2, R(3) = 2, R(4) = 3, R(5) = 4, its frequency sequence φ 0 (c) satisfies φ 0 (3) = 1. Since the solution sequence is monotone, the frequency sequence of the solution defines the solution sequence uniquely. We adopt the convention of giving frequency sequences the same sub- and superscripts

33 Chapter 2. The Basics: Trees, Sequences, and Pruning 27 as their corresponding recursion, for example, the solution to R s (n) has frequency φ s (n). First, note that the frequency of c must be one plus the number of labels after the c th leaf and before the (c + 1) st leaf; if n c is the label on the c th leaf, and n c+1 is the label on the (c + 1) st leaf, then R(n c 1) = c 1, R(n c ) = c, R(n c+1 1) = c, R(n c+1 ) = c + 1. Thus, the occurrences of c are the terms R(n c ), R(n c + 1),..., R(n c+1 1). We now need the following lemma. Lemma Suppose c is not a power of 2, and a is the largest integer with 2 a < c. Then φ 0 (c) = φ 0 (c 2 a ). Proof. Begin by locating the first supernode X with the property that the c th leaf descends from the right child of X. Note that X must be the (a + 1) st supernode. For example, in Figure 2.1, if c = 10, the first supernode whose right child is an ancestor of the 10 th leaf (the one containing 25) is the supernode containing 19 and 20. Now consider the twin of the c th leaf that descends from the left child of X; that is, that follows the same path of descent from X, but with the first right replaced by a left. On Figure 2.1, the twin of the 10 th leaf is the 2 nd leaf, the one containing 4. Note that the c th leaf and its twin both have the same number of labels between them and the next leaf (because the only differences between these parts of T (n) are supernodes, which are empty). Also, observe that the twin is the (c 2 a ) th leaf because the a th supernode has 2 a leaf descendants. This proves the lemma. We proceed to calculate the frequency sequence of the solution. Theorem The frequency φ s (c) = ν 2 (c)+1 if c is not a power of 2, and ν 2 (c)+s+1 if c is a power of 2, where ν 2 (c) is the 2-adic valuation of c, that is, the number of powers of 2 in the prime factorization of c. Proof. We start by proving this theorem for s = 0.