1 Introduction
The Fibonacci sequence is a sequence of positive integers whose terms are defined by the recurrence relation for all with the initial conditions and . So, the sequence is . Zeckendorf’s theorem [10] states that every positive integer can be represented uniquely as the sum of one or more distinct Fibonacci numbers in such a way that the sum does not include any two consecutive Fibonacci numbers. More precisely, if is a positive integer, then can be written uniquely as , where is either or , , if , then and is the Fibonacci number. Such a sum is called the Zeckendorf representation of . The Fibonacci code for , denoted by , is simply the binary string , where a 1 is appended at the end. It is interesting to note that although the theorem is named after the eponymous author who published his paper in 1972, the same result had been published 20 years earlier by Gerrit Lekkerkerker [6].
The Fibonacci code is a universal code which encodes positive integers into binary codewords. It was first defined by Apostolico and Fraenkel [1] and has applications in data compression. The Fibonacci code of any integer has the interesting property that it ends with and does not have any other consecutive 1’s in it. This property makes it a prefix code and thus a uniquely decodable binary code of variable size. Fibonacci coding is a selfsynchronizing code, making it easier to recover data form a damaged stream. This robustness property makes it useful in practical applications in comparison to other universal codes. The Fibonacci code for the first integers are shown in table 1.
1  11 

2  011 
3  0011 
4  1011 
5  00011 
6  10011 
7  01011 
8  000011 
9  100011 
10  010011 
11  001011 
12  101011 
13  0000011 
14  1000011 
15  0100011 
The Fibonacci sequence appears in the book Liber Abaci published by Fibonacci in 1202. However according to [9], the Fibonacci sequence appears in Indian mathematics in connection with Sanskrit prosody apparently as early as 450 B.C. About fifty years before the publication of Liber Abaci, Gopala and Hemachandra not only independently studied the Fibonacci sequence but also introduced a generalization of Fibonacci sequence known as the GopalaHemachandra Sequence (GH sequence for short). The GH sequence is defined using the similar recurrence relation for , with the initial conditions and , where and are arbitrary integers. In other words, GH sequence is simply the sequence where the initial numbers and are arbitrary integers. When and , it boils down to the Fibonacci sequence.
J.H. Thomas proposed a variation on the Fibonacci sequence in 2007 [7]. It is basically the same as GopalaHemachandra sequence in which the integer and . He extended the concept of the “Zeckendorf representation” to these variant sequences and also came up with the notion of the GopalaHemachandra code for an integer formed in a similar manner to the Fibonacci code. We will denote such a code for an integer using the notation . He also observed that may neither exist nor be unique when it exists. For example, when , he observed that there is no Zeckendorf representation for or . On the other hand, when , there are two different codes for viz., 01011 and 1000011.
In a computationally oriented paper [3] Basu and Prasad determined codes when they exist, in the range and . They noted that exists for and . They also observed codes do not exist for at most consecutive integers where and .
In this article, we generalize their limited computational observations into general mathematical statements and prove them. In Section 2 we show that exists for any positive integer (not just when ) provided . In Section 3, we develop two simple algorithms that determine whether exists for a given combination of parameters . Finally, in section 4, we show that codes do not exist for at most consecutive integers in general (i.e., without bounding or from above). Along the way, we point out some erroneous results published in the literature about GopalaHemachandra codes.
2 Universality of GH codes for
In this section, we prove that exists for any positive integer provided that or . The code is obtained by simply appending a to the Zeckendorf representation of and so all we need to do is to show that a Zeckendorf representation exists for any positive integer . It turns out that if an ordinary representation for exists, then it can be easily transformed into a Zeckendorf representation. We state and prove this result first.
Lemma 2.1.
Let there be an ordinary binary representation of using the integers of the sequence. In other words, let , where is either or and . Then there exists a Zeckendorf representation of . In other words, there exists such that, , where is either or , and if , then (in other words, no two consecutive numbers will be summed).
Proof:
Consider the bit string . Scan the string from right to left. Each time we find two consecutive ’s, we replace the substring by the string . It is easy to see that the value of the number represented is preserved as . It also follows that at the end of the process, the new bit string obtained will not have any consecutive 1’s in it and so is a Zeckendorf representation of .
Note that will either be equal to or . will be equal to if the rightmost two bits of the string are 1’s and will be same as in all other situations. ∎
We will denote the GopalaHemachandra Sequence by . Recall that and for . By the term initial segment of the GH sequence, we will denote the first five elements of it, viz., through . We will use the term remaining segment to denote the rest of the GH sequence, i.e, from onwards. Observe that the remaining segment has only positive integers and is a monotonically increasing sequence.
Theorem 2.2.
Let be a positive integer and be or . Then, there exists a Zeckendorf representation for . Consequently, the GopalaHemachandra codes are universal for or .
Proof:
In view of the Lemma 2.1, it suffices to prove that is the sum of some integers in the GH sequence. Let be the largest index from the remaining segment such that . Note that is well defined provided . If , then theorem is trivially true. So, let us assume that . Then clearly, . We have picked the integer . We now repeat the same process again, but this time using as the target integer. Note that the new target integer is smaller than the integer we picked. We repeat the same process again and again, until the target integer becomes smaller than . Let us denote the target integer when we stop as the remainder . Then, clearly is the sum of all the integers from the GH sequence that we picked plus . We now show that can be expressed as the sum of some integers from the initial segment of the GH sequence.
When , the initial segment of the GH sequence is . In Table 2, we show how to write
as the sum of some integers from the initial segment. Note that in the table, the second column is a binary vector of size 5, with a
in places corresponding to the GH sequence integer picked.0  00000 

1  00100 
2  10010 
3  10001 
4  00010 
5  00001 
6  00101 
7  01010 
8  01001 
When , the initial segment of the GH sequence is . In Table 3, we show how to write as the sum of some integers from the initial segment.
0  00000 

1  00100 
2  10010 
3  10001 
4  10101 
5  00010 
6  00001 
7  00101 
8  10011 
9  01010 
10  01001 
When , the initial segment of the GH sequence is . In Table 4 we show to write as the sum of some integers from the initial segment.
0  00000 

1  00100 
2  10010 
3  10001 
4  10101 
5  01000 
6  00010 
7  00001 
8  00101 
9  10011 
10  10111 
11  01010 
12  01001 
So, provided or , the remainder can always represented as the sum of some integers from the initial segment. Thus, provided or , any positive integer can be represented as a sum of some of the integers in the GH sequence. Now, using the Lemma 2.1 such a representation can be converted to a Zeckendorf representation. Hence, we conclude that the GH codes are universal for or . ∎
In [2], the abovementioned theorem is presented as Theorem 3.2. However, their proof is wrong. For example, when , the code constructed for as per the scheme outlined in their proof results in which is clearly not a Zeckendorf representation.
3 Algorithms to determine existence of GH codes
A natural algorithmic question that arises is to determine whether or not a GH code exists for a given set of parameters and . In this section, we present two different algorithms to answer this question, prove the correctness of these algorithms and comment on their complexity.
We first prove the following simple arithmetical result. This is similar to the result on Fibonacci numbers found in [5].
Lemma 3.1.
Let be an integer greater than or equal to 2. Then,
Proof:
First recall that, the GH sequence for the parameter is
.
We will prove this lemma by induction. For the base case, suppose . Then, . Also, . So, the statement is true when .
For the induction step, assume that the statement is true for some integer , so that we have . We need to show that . Now,
∎
To simplify notation, we use to denote the number in the GH sequence when there is no confusion about the parameter . We state and prove the following theorem which forms the basis of our algorithms.
Theorem 3.2.
Let be a positive integer. If can be realized as the sum of some numbers in the GH sequence, then there exists integers and satisfying the following conditions


, where are or and .

. where are or , and forms the Zeckendorf representation of which can be constructed using greedy algorithm.
Proof:
Suppose can be realized as the sum of some numbers in the GH sequence. Then, , where is 0 or 1 and . Let and . If , we set for . Thus and meets the condition 2 of the theorem.
Note that if , then , and or . If , then as is a positive integer. Consequently, for at least one value of . Let denote the smallest index greater than or equal to six, such that . Then we could slightly perturb the bits as follows. Set , and . Note that and are guaranteed to be 0 before we changed them. As , the sum of the numbers corresponding to 1 bits, still remains the same viz., . We can iterate this process again and again, until becomes . Note that, when we are through, through will remain unchanged and will either remain 0 or would have changed to 1. Now we set for . Then clearly
If , then or else the first five bits of the sequence is . In the later case, we can alter it to be without changing . So, without loss of generality, we can assume . Now, we can use the same technique used in the proof of Lemma 2.1 to eliminate these two consecutive 1’s. Let us denote the resulting bit sequence to be . Then, clearly , where .
Now that we have ascertained that , let so that the condition 1 stated in the theorem is satisfied. We do know that is the sum of some numbers in the remaining segment of the GH sequence. If that representation is not Zeckendorf representation, then it can always be transformed into a Zeckendorf representation using Lemma 2.1. All that remains to be shown is that the Zeckendorf representation can be found using a Greedy approach.
In order to construct the Zeckendorf representation of using a Greedy approach, we pick the largest GH sequence number not exceeding and then iterate the process. Let . Then, we claim that must pick . Suppose we did not pick . Let be the largest number that we can form without picking . We could pick the next largest number and as we cannot pick consecutive numbers from the GH sequence for Zeckendorf representation, we get
So, the net result is that . This means we cannot possibly form a Zeckendorf representation of using the remaining segment of GH sequence, if we don’t make the greedy choice of picking GH[m]. So, we must make the greedy choice of picking .
After having picked , we are now trying to make up the number . It is easy to observe that . So, the next integer picked will not be and so we will not have picked two consecutive GH sequence numbers. After each iteration, our target number decreases and should eventually become zero as we know that there is a Zeckendorf representation of using only the remaining segment of the GH sequence. So, we can indeed find the Zeckendorf representation of using the Greedy algorithm. ∎
We now present our first algorithm to check whether a code exists for a given integer .
The correctness of the algorithm shown in Figure 1 follows immediately from the proof of Theorem 3.2. As the initial segment is fixed in size, the representation of can be found in constant time, if it exists. The greedy technique to find a Zeckendorf representation for , if it exists, runs in linear time (proportional to length of representation of and thus of as ). Also, it takes only linear time to perform line no. 7 which is applying the technique of Lemma 2.1. As is completely determined by the parameter , the number of times the for loop is run is a constant (i.e., independent of ). So, the entire algorithm runs in linear time, when is considered a fixed parameter and is considered the input.
In practice, we will use the above algorithm only when , as we have already shown in Section 2 that GH code exists for any positive integer , when or . Therefore, let us assume that . Note that when , the GH sequence is . It is not difficult to see that, when , there are exactly 13 integers such that for which there is a representation using the initial segment of the GH sequence. Those thirteen integers along with their representation are given in Table 5.
0  00000 

1  00100 
2  10010 
3  10001 
4  10101 
k+5  01000 
k+6  00010 
k+7  00001 
k+8  00101 
k+9  10011 
k+10  10111 
2k+11  01010 
2k+12  01001 
So, representation for using the initial segment, does not exist if or if . In all other cases, where , representation for and can be found by looking up in the Table 5. As such, line 2 of the algorithm shown in Figure 1 can be implemented in the above manner.
We now develop a more efficient algorithm than the Algorithm shown in Figure 1. Our efficient algorithm is depicted in Figure 2. The algorithm relies crucially on the following two lemmas.
Lemma 3.3.
Let be a positive integer. Suppose a GH code exists for that is not produced by the greedy algorithm, then the second bit of the code must be a .
Proof:
Recall that the greedy algorithm proceeds by repeatedly picking the largest GH sequence number that can be picked while making sure that the sum of the numbers picked does not exceed . If the GH code for is not produced by the greedy algorithm, then it picks a different number than suggested by the greedy algorithm at some point. Let us focus on the first time there is a difference. Let denote the difference between and the numbers already picked up to this point of time. Suppose the greedy algorithm suggests picking as is the largest index such that . If we don’t pick , let denote the largest number that we can form using the other GH sequence numbers while not including GH[2]. Then, we have
So, it is impossible to make up the remainder , unless is also used. Hence, the second bit of the GH code for must be a . ∎.
Lemma 3.4.
Let be a positive integer. Suppose a GH code exists for that is not produced by the greedy algorithm, then the fourth bit of the code must be a .
Proof:
By Lemma 3.3, we already know that the second bit of the GH code must be a . So, the third bit must be a zero, as the code cannot have two consecutive 1’s in it.
If the GH code for is not produced by the greedy algorithm, then it picks a different number than suggested by the greedy algorithm at some point. Let us focus on the first time there is a difference. Let denote the difference between and the numbers already picked up to this point of time. Suppose the greedy algorithm suggests picking as is the largest index such that . If we don’t pick , let denote the largest number that we can form using the other GH sequence numbers while not including GH[4]. Then, we have
So, it is impossible to make up the remainder , unless is also used. Hence, the fourth bit of the GH code for must be a . ∎.
Given an integer , we can use the greedy algorithm over the remaining segment of the GH sequence (i.e., from GH[6] onwards) and let denote the sum of the numbers from the sequence picked up. Let . If has a representation using the initial segment of the sequence (which can be determined by looking up the Table 5), then we can concatenate the code for and the code for and then apply Lemma 2.1 if needed to get the code for .
Note that if cannot be represented using the initial segment, there is still a possibility that GH code for exists. However, in this case the code must be something that is not produced by the greedy algorithm working with input .
In view of Lemma 3.3 and Lemma 3.4, we know that if there is a GH code for , that is not produced by the greedy algorithm, then the second bit and the fourth bit must be . However, as the GH code cannot have consecutive 1’s except at the end, the initial segment of the GH code must be “01010” (if the code length is longer than 5). Now, let . Let . In view of Theorem 3.2, we can claim that must be greedily constructible using the remaining segment of the GH sequence, as this is the only value for that works for this . This establishes the correctness of algorithm shown in Figure 2.
Both the algorithms have the same asymptotic complexity, viz., linear time in the length of the representation of code for . However, the second algorithm is much more efficient in a practical sense, as it constructs the code for in just two attempts, if it exists.
In [4], the authors present two algorithms to determine whether code exists for a given set of parameters and . Their second algorithm makes use of their first algorithm and so we will focus on their first algorithm only here. The main issue is that although they have presented the algorithm (see Method 1 in page 164), they did not bother to prove that their algorithm is indeed correct and also they did not bother to analyze the complexity of their algorithm. Also, the algorithm is not described precisely and hence is hard to follow. Finally, their algorithm as presented is wrong. For example, if , the algorithm returns the string “10000000110011” as the code for , which is clearly wrong as it contains consecutive 1’s in the middle.
4 Nonexistence of GH codes for consecutive integers
In [3], Basu and Prasad observed that there are at most consecutive integers for which code does not exist when and . They made this observation using the tables they created for GH codes when and . We turn their numerical result to a mathematical theorem and show that the result is valid well beyond the limited range considered by them. We show that the result is true, even when . Moreover, we show that the result is true for the entire set of positive integers (i.e., there is no need to upper bound ).
Theorem 4.1.
Let be a positive integer. Then, there exists at most consecutive integers for which codes do not exist.
Proof:
Let be an integer for which a code does not exist. Let us attempt to construct using the greedy algorithm applied to the remaining segment of the sequence. In this process, we would have picked some integers from the remaining segment of the GH sequence. Let the sum of the integers we picked be . Let . Observe that , as otherwise, we would have picked in the last step of the greedy algorithm. Then, it should not be possible to represent as the sum of some integers from the initial segment of the GH sequence (i.e., from GH[1] to GH[5]). For, if we were able to represent as the sum of some integers from the initial segment, then by Theorem 3.2, we know that there is a GH code for which contradicts with the assumption made at the beginning.
Now, let and be two consecutive integers (with ) for which codes do not exist. When we run the greedy algorithm on and , we will choose the same number from the GH sequence at every step. Hence will be same as . So, we can conclude that and will be two consecutive integers, that are not representable as the sum of some integers from the initial segment. Moreover, .
By extension of the above argument, we can claim that if there are consecutive integers for which code does not exist, then there must be consecutive integers (each one of which is greater than or equal to and less than ), that are not representable as the sum of some integers from the initial segment of the GH sequence. However, as we can see from Table 5, this is not possible. The sequence of numbers from to are not representable, but this sequence has only elements. Again, the sequence of numbers from to are not representable, but this sequence also has only elements.
Thus, there does not exist consecutive integers for which code does not exist. ∎
5 Concluding Remarks
In this article, we showed that a code exists for any positive integer , when and . We presented two algorithms to determine whether or not a code exists for a given set of parameters and . Moreover, our algorithms construct such a code, if it exists. Both our algorithms run in linear time in the length of the code, but our second algorithm is faster than the first in practice. Finally, we proved that there are at most consecutive integers for which a code does not exist. This result is observed to be true earlier in limited ranges for and . But, we are able to establish it unconditionally.
The third order GopalaHemachandra codes are defined using the recurrence relation , for and the initial conditions , and . In [8], Nalli and Ozyilmaz determined tables of codes for and . However, [8] is a computationally oriented paper and does not have general results. It appears that codes are universal for . Moreover, it appears that there exists at most consecutive integers for which code does not exist. Both of these observations are true in the limited range for which tables are constructed in [8]. It would be nice to prove these two statements. Also, it would be nice to come up with an algorithm that, given and , determines whether code exists for and if so, constructs the code.
In a natural way, higher order GopalaHemachandra codes (fourth order, fifth order etc) can be defined. It would be nice to come up with a function and prove that codes are universal if and only if . Finally, it would also be interesting to see whether a very general algorithm can be developed that takes and as input and determines whether code exists for integer and if so, constructs the code.
References
 [1] A. Apostolico and A. Fraenkel, Robust transmission of strings using Fibonacci representations, IEEE Trans. Inform. Theory 33 (1987), 238245.
 [2] Manjusri Basu and Monojit Das, Uses of second order variant Fibonacci universal code in cryptography, Control and Cybernetics 45 (2016), 239257.
 [3] Manjusri Basu and Bandhu Prasad, Long range variations on the Fibonacci universal code, Journal of Number Theory 130 (2010), 19251931.
 [4] Joydeb Pal and Monojit Das, The GopalaHemachandra universal code determined by straight lines, Journal of Mathematics and Computer Science 19 (2019), 158170.
 [5] Lucas, Édouard, Théorie des nombres (in French), GauthiarVillars Publishers, (1891), Paris.
 [6] C. G. Lekkerkerker, Voorstelling van natuurlijke getallen door een som van getallen van Fibonacci, Simon Stevin 29 (1952), 190195.
 [7] J. H. Thomas, Variations on the Fibonacci universal code, arXiv:cs/0701085v2 (2007), 4 pages.
 [8] Ayse Nalli and Cagla Ozyilmaz, The third order variations on the Fibonacci universal code, Journal of Number Theory 149 (2015), 1532.
 [9] Parmanand Singh The socalled Fibonacci numbers in ancient and medieval India Historia Mathematica 12 (1985), 229244.
 [10] E. Zeckendorf, Representation des nombres naturels par une somme des nombres de Fibonacci ou de nombres de Lucas, Bull. Soc. Roy. Sci. Liege 41 (1972), 179182.