On the Structure of Low Autocorrelation Binary Sequences Svein Bjarte Aasestøl University of Bergen, Bergen, Norway December 1, 2005 1
blank 2
Contents 1 Introduction 5 2 Overview 5 3 Denitions 6 3.1 Shift operation............................ 6 3.2 Hamming distance.......................... 7 3.3 The Autocorrelation function (ACF)................ 7 3.4 The search basics........................... 10 3.4.1 Collisions........................... 11 3.4.2 Child............................. 11 3.4.3 Parent............................. 12 3.4.4 Sibling............................. 12 3.4.5 Loop.............................. 12 3.4.6 Tail.............................. 12 3.4.7 End Tail............................ 13 3.4.8 Singularity.......................... 13 4 The Basic Loop Search 15 5 Analysis of the Loop Search using the All Zero Sequence 20 5.1 Periodic loop search, cyclic collision................ 20 5.2 Periodic loop search, negacyclic collision.............. 23 5.3 Negaperiodic loop search....................... 24 5.4 Aperiodic loop search........................ 28 6 Analysis of the tail and loop sizes 30 6.1 A closer look at the relation between parent and child sequences 30 6.2 Recursive end tail search....................... 32 7 Symmetries in the structure of loops and tails 35 8 Exhaustive search 43 8.1 exhaustive pc loop search...................... 43 9 Exhaustive nn loop search 46 10 Exhaustive ac loop search 47 10.1 connecting periodic and negaperiodic energies........... 49 11 Loop sibling search 53 12 sliding window, aperiodic search 54 13 Aperiodic energies for any sub-length 58 14 Alternating loop search 64 15 Complexity and programming 66 15.1 Computing the energy......................... 67 3
15.2 Finding the loop........................... 67 15.3 Memory................................ 67 15.4 Other................................. 68 16 Open questions 68 17 Conclusion 68 18 End notes 69 4
1 Introduction In modern communication systems and system engineering, the need for binary sequences is steadily growing. Such sequences are used for the commonly used cell phone and for more advanced elds such as radar and sonar signals. However not all sequences are equally useful. For some areas of technology we need certain criteria to be fulllled with regard to the sequences, for them to be of any use to us. One of these is that the sequences should have low autocorrelation values. Finding such sequences for low lengths is easy, since we just have to do a complete exhaustive search of all the 2 x sequences, where x is the sequence length. However once we start to increase our sequence length, the total number of sequences grows exponentially. Since the amount of sequences with low autocorrelation values stays relatively low, the chance of nding one very rapidly diminishes. It does not take a very big increase in sequence length to make these kinds of searches computationally infeasible. While this eld of research is not new, it is still growing and needed more then ever before. While there are already several methods to construct sequences with low autocorrelation values, we will take a closer look at the relation between the sequences, using a sort of evolutionary search which starts by going down a path or trajectory in the full set of sequences and terminates in a set of resonating sequences dened by our search parameters. We hope that nding data about this structure will help us nd ways to skip parts of the process of nding these resonating sequences. Also we hope to use this structure to make changes to our initial search and thus be sure that if we start out with a random or other easily constructed sequence, we search to nd another sequence with a signicantly better autocorrelation value. Finally we aim to construct long, semi-innite sequences such that subsequences of such sequences have favorable spectral properties. 2 Overview In this thesis we will rst apply our search using the all zero sequence, {0,0,0,...,0} as input for dierent sequence lengths N. We will observe and analyze the structures this input, for dierent parameters, will generate. Then after this initial test of our search, we will take a closer look at the basic structure and relation of each step of our search. Analyzing this, we will then perform our search backwards, starting with sequences that have good autocorrelation properties. Our hope is that this might reveal a pattern to which sequences are connected to these low autocorrelation sequences. Further we will investigate how negated sequences are related, and how negating all sequences, or some of them in our structure will aect the structure as a whole. With this in mind we will do some exhaustive searches for low length sequences, especially noting parameters that are oppositional but generating structures that behave surprisingly similar, namely using periodic and negaperiodic autocorrelation. We will also look at the exhaustive search of aperiodic autocorrelation structures. Also, we will investigate ways to transform sequences from periodic autocorrelation into negaperiodic autocorrelation equivalents, using special transform sequences. Pos- 5
sibly we might be able to nd a way to directly transform one structure of a given type into another structure of another type, but still equivalent. Following this we intend to modify our search, so that we can use results from one search to possibly improve results of the next. Also by alternating our search parameters while performing our search might prove interesting, or using one parameter to optimize, while actually being interested in another parameter.. We will show that there are in fact several interesting structures and patters forming, depending on which parameters we use. Even the trivial all zero sequence can occasionally let our search terminate nding m-sequences. Symmetric properties are abundant, and we can show that structures in the periodic and negaperiodic autocorrelation environment are closely related both in size and behavior. Then we will generate new sequences, by taking one bit of each sequence in our structure. Using this new sequence, we will apply a sliding window, and show that for each subsequence the aperiodic properties are on average signicantly better then for random sequences. 3 Denitions Sequence The rst object we need a clear denition for is a Sequence. One possible denition would be: sequence: An arrangement of items according to a specied set of rules, for example, items arranged alphabetically, numerically, or chronologically. In this thesis we will be working on nite sequences where sequence S = {s 0, s 1, s 2,..., s N 1 } for N 1 such that s {-1,+1}. However for our purposes we can represent the same sequence S by using the alphabet s i {0,1}, where 1 = 1 0 and 1 = 1 1, which gives us the possibility to read each element of the sequence as a binary number, or as bits which a computer can use to represent any number, character or instruction. Bits have the value of False or True, or 0 and 1. One element in a sequence will in this thesis be referred to as a bit or several elements as bits. Only in the autocorrelation function will s i {-1,+1} be used to calculate a given sequences energy. 3.1 Shift operation This is the most basic operation we will be performing on the sequences. A shift operation is done by moving all bits in a Sequence one (or more) steps to the right or left. Let S = {s 0, s 1, s 2,..., s N 1 } be a sequence of length N. A right cyclic shift on S can be dened as Denition 1 Shift(S) = S i S i+1(mod N) i i {0,1,..., N-1} Example: Shift operations performed on the sequence s = {000111} 6
right shift operation Initial 0 0 0 1 1 1 cyclic 1 0 0 0 1 1 negacyclic 0 0 0 0 1 1 acyclic 0 0 1 1 1 left shift operation Initial 0 0 0 1 1 1 cyclic 0 0 1 1 1 0 negacyclic 0 0 1 1 1 1 acyclic 0 0 1 1 1 For clarity we will name the shift operations, used on a sequence S as crshift(s) = Cyclic Right Shift of S nrshift(s) = Negacyclic Right Shift of S arshift(s) = Acyclic Right Shift of S clshift(s) = Cyclic Left Shift of S nlshift(s) = Negacyclic Left Shift of S alshift(s) = Acyclic Left Shift of S 3.2 Hamming distance This metric is used to measure dierences between two given sequences. The Hamming distance can be dened as follows The minimum number of bits that must be changed in order to convert one bit string into another. or more formally, the Hamming distance between two strings A and B, each of length N: Denition 2 H(A, B) = N 1 i=0 A i B i 3.3 The Autocorrelation function (ACF) We then need a denition for the autocorrelation function (ACF). The autocorrelation function measures self similarity of a binary sequence. We consider three types of autocorrelation: periodic, negaperiodic and aperiodic. The periodic autocorrelation is by far the most studied. In this thesis we will use and look at all three types of autocorrelation, but with a slight focus on the periodic and aperiodic. The periodic autocorrelation (PACF) will measure the correlation of a sequence with the cyclic shift of itself. Let s be a binary sequence of length N, such that s = {s 0, s 1,..., s N 1 }, s i Z 2, and s i = 0, i < 0, i N. Then the periodic autocorrelation function is dened as N 1 P ACF k (s) : p k = ( 1) si s i+k, 0 k < N. (1) i=0 7
The parameter N represents the period of the cyclic shift, k is the shift index at which the sequence is compared to itself, and the sequence indices, i, are taken mod N. Another measure of the autocorrelation is the negaperiodic autocorrelation (NACF). NACF will measure the correlation of the negacyclic shift of a sequence against itself. The function is dened as Denition 3 NACF k (s) : n k = N 1 i=0 ( 1)si s i+k k+i N, 0 k < N. N now represents half the period of the sequence. Once again the indices i are taken mod N. A third way to measure the autocorrelation is a combination of periodic and negaperiodic called the aperiodic autocorrelation function (AACF). When we combine the periodic and the negaperiodic shifts of the sequence, we lose the periodicity of the shifted sequence. Instead of shifting the sequence cyclically, we compare the window of indices where both the shifted sequence and sequence itself exist. The AACF is then dened as Denition 4 AACF k (s) : a k = N k 1 i=0 ( 1) si s i+k, 1 k < N We can also represent PACF, NACF and AACF as polynomial multiplication. A binary sequence s = (s o, s 1, s 2,..., s N 1 can be associated with the polynomial s(x) = s 0 + s 1 x + s 2 x 2 +... + s N 1 x N 1. We can dene where and p(x) := P ACF (s(x)) = s((x)s(x 1 )(mod x N 1), (2) n(x) := NACF (s(x)) = s(x)s(x 1 )(mod x N + 1), (3) a(x) := AACF (s(x)) = s(x)s(x 1 ), (4) p(x) = n(x) = a(x) = N 1 k=0 N 1 k=0 N 1 k=1 N p i x i, (5) n i x i, (6) a i x i. (7) This representation includes all shifts N < k < N, where the autocorrelation for the kth shift is the coecient for x k. Example: Let N = 5 and s = 01011. The P ACF k is {5,-3,1,1,-3}, NACF k is {5,-1,1,-1,1} and the AACF k is {5,-1,1,0,-1} as seen below: This can also be written in polynomial form as P ACF (S(n)) = 5 3x + x 2 + x 3 3x 4. (8) NACF (S(n)) = 5 x + x 2 x 3 + x 4. (9) 8
k Cyclic shift P ACF k Negacyclic shift NACF k Acyclic shift AACF k 0 01011 5 01011 5 01011 5 1 10101-3 00101-1 0101-2 2 11010 1 00010 1 010 1 3 01101 1 10001-1 01 0 4 10110-3 01000 1 0-1 Table 1: Showing periodic, negaperiodic and aperiodic autocorrelation. AACF (S(n)) = x 4 + x 2 2x 1 + 5 2x + x 2 x 4. (10) A common metric used to measure binary sequences with low aperiodic autocorrelation is the Golay Merit Factor (MF) proposed by Golay. The periodic Merit Factor of a binary sequence s, of length N is given by MF a (s) = For periodic autocorrelation we will be using MF p (s) = N 2 2. (11) N 1 k=1 a2 k N 2 N 1, (12) k=1 p2 k the negaperiodic Merit Factor of a binary sequence s, of length N is given by MF n (s) = N 2 N 1, (13) k=1 n2 k and the aperiodic Merit Factor of a binary sequence s, of length N is given by MF a (s) = N 2 2. (14) N 1 k=1 a2 k In this thesis we will be looking at all three Merit Factors, and the Merit Factors will be labeled MF p, MF n and MF a, however any outputs from our program will be usually labeled with the type of Merit Factor rst, i.e. pmf, nmf and amf. The higher the Merit Factor, the lower the values p k, n k and a k, 1 k < N. Note that the trivial autocorrelation coecient, where a 0 = N is not used in the calculations of the Merit Factor. Another metric we will use for binary sequences with low autocorrelation is the sum-of-squares, σ p, σ n, or σ a given by σ p (s) = σ n (s) = σ a (s) = N 1 k=1 N 1 k=1 N 1 k=1 9 p k 2. (15) n k 2. (16) a k 2. (17)
For brevity we will refer the sum-of-squaresas the Energy. The type of Energy a sequence can have is periodic, negaperiodic or aperiodic. We can see that σ is a part of the Merit Factor function, and the Merit Factor function can be written with the use of σ, for example the periodic Merit Factor is given by MF p (s) = N 2 Example: If N = 5 and s = 01011 the p k values are {5,-3,1,1,-3}. The sum-of-squares or Energy is then 2σ p. (18) σ p = ( 3) 2 + (1) 2 + (1) 2 + ( 3) 2 = 9 + 1 + 1 + 9 = 20. (19) The periodic Merit Factor for this sequence is then MF p (s) = 25 = 0.625. (20) 2(20) 3.4 The search basics The most important operation in our searches is the generation and selection of the next generation sequence. By starting out with a random binary sequence, S 0, we proceed to generate two new sequences based on S 0 by performing a right cyclic shift and a right negacyclic shift. Then we calculate the energy for both sequences S 1c and S 1n. The sequence with the lowest Energy is chosen and used as input for the next step. Should they have equal energy, there is a collision and we must use a method to decide which of them we should choose. This will eventually lead us to having a chain of sequences S 0, S 1, S 2,...,S n. Since we are working with sequences of length N, we have a nite number 2 N to choose from. Because of this, at some point our newly generated sequence S n will be identical to a previously chosen sequence S n x. At this point we terminate our search, as continuing would only lead to generating the same sequences over and over. Thus we have found our resonating sequences. Example: Given the sequence S 0 = {0000} and using periodic Energy, we then generate and S 1c = crshift(0000) = 0000, (21) S 1n = nrshift(0000) = 1000. (22) We then calculate the periodic Energy for S 1c and S 1n Energy p (S 1c ) = 48. (23) Energy p (S 1n ) = 0. (24) 10
We see that S 1n has the lowest periodic energy, so we choose that as our S 1. Now we repeat this process using S 1 as our initial sequence and nd S 2c and S 2n again we calculate their periodic Energy and nd S 2c = crshift(1000) = 0100, (25) S 2n = nrshift(1000) = 1100, (26) Energy p (S 1c ) = 0, (27) Energy p (S 1n ) = 16, (28) so we choose S 1c since it has the lowest periodic energy and set it as S 2. Now we have the set of sequences S = {0000}, {1000}, {0100}. If we keep repeating this process, we nd that the next sequences we choose will be S 3 = {0010}, S 4 = {0001}, S 5 = {1000}. Now, for every new sequence we choose, we must continually check back in the set S to see if we at any point generate and choose a sequence that already exists in S. We can see that in this example, S 5 = {1000} is identical to S 1. Proceeding any further is pointless as we will end up looping forever where we will repeatedly choose S 1, S 2, S 3, S 4 in this order. As we perform this and similar searches, some relations and structures of binary sequences show up very frequently and it is useful to dene them. 3.4.1 Collisions It is possible that, given a sequence S 0, after we generate two sequences S 1c and S 1n from S 0, we have the case that Energy(S 1c ) = Energy(S 1n ). When this occurs, we have a collision, meaning we can not know which of the two sequences would be the better choice to continue with. Example: Given the initial sequence S 0 = {10101}, we generate S 1c = {11010} and S 1n = {01010} by doing a cyclic right shift and a negacyclic right shift on S 0. By calculating the periodic energy for S 1c and S 1n we see that Energy p (S 1c ) = Energy p (S 1n ) = 20. (29) Thus we have a collision between S 1c and S 1n. 3.4.2 Child Starting with sequence S 0, we generate the sequences S 1c and S 1n and choose one based on our parameters. The sequence we choose is the best case child sequence of the original. All sequences have a child sequence. Note: While both sequences generated are children of the original sequence, the term child will be commonly used to describe the child sequence we would choose after looking at their energies. 11
3.4.3 Parent Starting with a sequence S 0, generate the sequences S 1c and S 1n. We now check for both the new sequences, which of them would choose S 0 as it's child (see Child). These are the structural parent(s 0 ) of S 0. A sequence can have 0, 1 or 2 parents that choose that sequence as the one with lowest energy. Note: As in child above, we here also have two possible sequences to choose from, but in this case they are parent sequences. Unlike in child however, where we must choose either of the children, with parent sequences it is likely that both parent sequences would lead to the same child. This property is important for estimating the number of End Tail sequences within a eld of sequences. We will look at this later. 3.4.4 Sibling This term describes the relation between two children. One child sequence can be called the sibling of the other child sequence (see: child). The easiest way to generate the sibling of a given sequence is to ip the rightmost bit. Note: a pair of sequences being siblings, have the same two parent sequences also. 3.4.5 Loop The most important structure in this thesis. This represents a chain of sequences S 0, S 1, S 1,..., S n such that starting with sequence S 0 and repeating our sequence generation method described above, we will traverse all the sequences in order and nd that S n = S 0. Example: The sequences 1000, 0100, 0010, 0001 form a Periodic energy, (see: the search basics) cyclic collision Loop. Starting with any one of the above sequences, generate S n+1c and S n+1n, and calculate their energy. Then we choose the generated sequence with lowest periodic energy. Repeating this process will lead us to loop around these four sequences 3.4.6 Tail As mentioned in the explanation above, if we start with a random sequence and perform the sequence generation method repeatedly, we nd that some sequences might not be part of the loop. These sequences form what can be described as a tail or transient. For example given a chain of sequences S 0, S 1, S 2,...,S n, where S n+1 = S 2, the sequences S 0 and S 1 would be elements of the tail. Generally, but far from always, a loop will have a tail for every sequence within the loop. Example: If we use the same parameters as in the Loop example, the sequence S 0 = 0000 will be a tail. If we start with this given sequence, generate S 1c and S 1n which are 0000 and 1000, and calculate their periodic energy, then Energy p (S 1c ) = 48 and Energy p (S 1n ) = 0. We see that our search will choose 12
S 1n or 1000 as the current best sequence. If we look at the example above in loop denition, we can see now that repeating the process will lead us to be caught within the loop described above. 3.4.7 End Tail If we generate "backwards" and nd S 1c and S 1n, then if neither of the two sequences would nd that S 0 is with highest energy, then S 0 is an end tail. In other words, starting at any other sequence of the same length, our search will never pass through this S 0 sequence given the parameters. Example: Using the same sequence as above, we can show that the All Zero sequence is not only a tail sequence, but also an end tail sequence. Let us generate the sibling sequence of 0000, which is 1000. We see that both sequences have the same parent sequences, namely 0000 and 0001. If we calculate the periodic energy for the sibling pair, we get that pe(1000) = 0 and pe(0000) = 48, thus we get that 0000 will not be chosen by either of it's parents and is an End Tail sequence. In other words: the only way for our search to include this sequence in a structure, is by starting with it as input. 3.4.8 Singularity This is a very special case of the Loop structure. In this case we have a sequence, where the same sequence is both its own parent and child. Thus the whole loop and tail is made up of one sequence. There are for any sequence length only two possible cases of a singularity appearing. In order for a sequence to be both it's own child and parent, a cyclic or negacyclic shift must result in itself. The only sequences for which this is at all possible are the cases of the All Zero Sequence, 0000...0, and it's negation the All Ones Sequence, 1111...1. Now we can look at how these sequences behave when we generate their children. First we start with the All Zero Sequence of length N = 5, generate the two children by performing a cyclic right shift and a negacyclic right shift. This will give us the sequences 00000...0 and 1000...0. We see that the All Zero Sequence has the maximum possible periodic energy. k P ACF k p k p k 2 0 0 0 0 0 0 1 0 0 0 0 0 = 5 25 2 0 0 0 0 0 = 5 25 3 0 0 0 0 0 = 5 25 4 0 0 0 0 0 = 5 25 The length of the sequence is irrelevant as in this case, the all-zero sequence regenerates always itself. However should we ip the leftmost bit the situation changes and for N = 5, we get the following table: 13
k P ACF k p k p k 2 0 1 0 0 0 0 1 0 1 0 0 0 = 1 1 2 0 0 1 0 0 = 1 1 3 0 0 0 1 0 = 1 1 4 0 0 0 0 1 = 1 1 We see that for every row there will be 2 bits that dier, and N-2 bits that are equal. Increasing the sequence length by adding zeros will not change this. Thus we can see that for periodic energy, the All Zero Sequence will never choose itself as it's best case child. If we use aperiodic energy, the tables are essentially the same, except half of the energy will disappear because of the aperiodic structure. k AACF a a k a k 2 0 0 0 0 0 0 1 0 0 0 0 = 4 16 2 0 0 0 = 3 9 3 0 0 = 2 4 4 0 = 1 1 We see in the above table, that the All Zero Sequence gives the maximum possible aperiodic energy for a given length. Looking at the sibling sequence we see that introducing one negated bit aects the table almost identically to the case for periodic energy. k AACF a a k a k 2 0 1 0 0 0 0 1 1 0 0 0 = 2 4 2 1 0 0 = 1 1 3 1 0 = 0 0 4 1 =-1 1 Again we see in the above table that one single bit has a major impact on the total sum. As with the periodic cause, the autocorrelation value will be one less then the autocorrelation for the All Zero Sequence for any length n. Thus, for aperiodic energy, the All Zero Sequence will never choose itself as it's best case child. Setting up the same tables for negaperiodic energy will show us some interesting properties. k NACF n n k n k 2 0 0 0 0 0 0 1 1 0 0 0 0 = 3 9 2 1 1 0 0 0 = 1 1 3 1 1 1 0 0 = -1 1 4 1 1 1 1 0 = -3 9 If we compare the above table with the All Zero sequence's sibling, as shown in the table below, we see that the tables are nearly identical. 14
k NACF n n k n k 2 0 1 0 0 0 0 1 1 1 0 0 0 = 3 9 2 1 1 1 0 0 = 1 1 3 1 1 1 1 0 = -1 1 4 1 1 1 1 1 = -3 9 An analysis of these two tables is in order. We see that both tables have one column that consists of always the same number. In the All Zero Sequence table, the last column contains only zeros. Decreasing or increasing the sequence length n will not change the last column. The rst n-1 columns will form an (n-1)*(n-1) matrix where exactly half of the values will be 0 and the other half 1. This also holds true for any length n. Looking at the second table, we can see the same properties. The rst column will always consist of 1's, regardless of sequence length, while the columns 2-n will also form a matrix (n-1)*(n-1) which is exactly identical to the rst. Thus we get that for any sequence of any length, the energy table will be made up of two identical parts for both the all zero sequence and it's sibling. Both will have a (n-1)*(n-1) matrix which is identical, and a column on the side which will provide identical values. Thus we have that for the All Zero Sequence of any length, it and it's sibling will always have identical negaperiodic energy tables, or in other words identical negaperiodic energy. Further selecting the cyclic child in case of a collision (which always appear in this case), we have that for any length n, the All Zero Sequence will always choose itself as best case child, thus we have a Singularity. For all practical purposes the reasoning used above holds for the All Ones Sequence, except that all bits are negated. To make things simpler we will dene a xy- prex for tails and loops to easier identify what parameters we used to generate them. This can be dened as Denition 5 a prex xy such that x {p, n, a} and y {c, n}. where the set {p, n, a} represents the three possible energies: periodic, negaperiodic, aperiodic, and the set {c, n} represents the two possible collisions: cyclic and negacyclic. 4 The Basic Loop Search The Basic Loop Search forms the most basic of our search methods. Starting out with an arbitrary sequence s 0, we proceed to generate subsequent sequences s 1, s 2, s 3,... until we hit a Loop. The easiest Loop to nd is when we use periodic autocorrelation and cyclic default collisions. These parameters make the structure we get very predictable, and this can be exploited in our program, reducing the CPU power needed. Generating a Loop from the all zero sequence, length 10 is shown in Table 2 Although the all zero sequence has the worst possible energy using periodic autocorrelation, this table serves to show the general structure of the Loop. We can see how we started out with a given sequence which has a rather high periodic energy and within very few steps, we have found the local minimum for energy. The periodic merit factor for the 15
Tail 0000000000 (pe: 900) 1000000000 (pe: 324) 1100000000 (pe: 100) 0110000000 (pe: 100) Loop 1011000000 (pe: 36) 0101100000 (pe: 36) 0010110000 (pe: 36) 0001011000 (pe: 36) 0000101100 (pe: 36) 0000010110 (pe: 36) 0000001011 (pe: 36) 1000000101 (pe: 36) 1100000010 (pe: 36) 0110000001 (pe: 36) Table 2: A periodic energy search using cyclic collision default (pc-loop search). First four sequences make up the tail, while the last ten form a loop loop is not extremely high, but most denitely an improvement from the start. Initial periodic merit factor = 0.111..., Loop periodic merit Factor = 2.333.... It should be noted that already in this example the need for deciding a default choice in case of collision shows up. The full output for this particular Loop search is shown in Table 3. The Sequences on the left side are those chosen by the program as best case, while the right side side sequences are those discarded, given our input parameters. Each row consists of the two children from the chosen sequence at the row above. If we look closer at this particular example, we can see that the tail-sequence nr 3. {110000000} generates two children, {0110000000} and {1110000000} that have the same periodic energy. At this point we have a collision and we must decide which path to follow. For simplicity our searches will strictly choose either the cyclic child or the negacyclic child as default in case of collisions. Some other possible ways of solving this could be: randomly choosing which sequence to accept as the new best case, or use another metric to measure them, for instance calculating the aperiodic or negaperiodic energy for both, and make a decision based on this new metric. Using the periodic autocorrelation as the parameter causes all cyclic shifts of one sequence to have the same periodic energy as the initial sequence. When we also decide on using the cyclic collision default, we then eectively force every Loop we nd to consist of N sequences, where N = sequence length. If we use strictly negacyclic collisions, we nd that this does not necessarily hold. We will see later that using negacyclic collisions does not guarantee Loops of size N. Table 4 is a comparison of the two Loop searches using rst cyclic then negacyclic collisions. Tail Cyclic Default Negacyclic Default 0000000000 (pe: 900) 0000000000 (pe: 900) 1000000000 (pe: 324) 1000000000 (pe: 324) 16
1100000000 (pe: 100) 1100000000 (pe: 100) 0110000000 (pe: 100) 1110000000 (pe: 100) 0111000000 (pe: 100) 1011100000 (pe: 68) Loop 1011000000 (pe: 36) 1101110000 (pe: 36) 0101100000 (pe: 36) 0110111000 (pe: 36) 0010110000 (pe: 36) 1011011100 (pe: 36) 0001011000 (pe: 36) 0101101110 (pe: 36) 0000101100 (pe: 36) 0010110111 (pe: 36) 0000010110 (pe: 36) 0001011011 (pe: 36) 0000001011 (pe: 36) 1000101101 (pe: 36) 1000000101 (pe: 36) 1100010110 (pe: 36) 1100000010 (pe: 36) 0110001011 (pe: 36) 0110000001 (pe: 36) 0011000101 (pe: 36) 1001100010 (pe: 36) 0100110001 (pe: 36) 0010011000 (pe: 36) 0001001100 (pe: 36) 0000100110 (pe: 36) 1000010011 (pe: 36) 1100001001 (pe: 36) 1110000100 (pe: 36) 0111000010 (pe: 36) 1011100001 (pe: 36) Table 4: Comparison between a pc-loop and a pn-loop, starting with the same sequence s 0 = {0000000000}. In table 4 we can see how much the two loops dier simply by having to decide upon one or the other collision default. Another interesting observation is that the negacyclic collision Loop is now made up of parts of other cyclic collision loops. The bold faced sequences show every time when we have a collision. We can see that they are cyclically inequivalent. Another interesting observation here is that, contrary to what one might have expected, the distribution of sequences from each cyclic collision Loop are not even. Counting the sequences from the dierent Loops gives us 3+3+4+3+2+5 = 20. If we move on to looking at the negacyclic autocorrelation, also starting with the all zero sequence, we get a new pattern in the Loop. For the Loop search with cyclic collisions, the best case Sequence for 0000000000 is itself. This holds for any time we start with the all zero sequence for any length of N. Thus we have a singularity. This can only happen for the all zero or the all ones sequences. However if we take a look at the negacylic collision option, we get a more expected output. The all zero sequence will yield the loop shown in Table 5 Chosen Sequences Tail Discarded Sequences 17
0000000000 (ne: 240) 1000000000 (ne: 240) 0000000000 (ne: 240) 0100000000 (ne: 144) 1100000000 (ne: 240) 0010000000 (ne: 80) 1010000000 (ne: 144) 0001000000 (ne: 48) 1001000000 (ne: 80) 1000100000 (ne: 48) 0000100000 (ne: 48) Loop 0100010000 (ne: 16) 1100010000 (ne: 48) 1010001000 (ne: 16) 0010001000 (ne: 80) 1101000100 (ne: 16) 0101000100 (ne: 48) 1110100010 (ne: 16) 0110100010 (ne: 48) 1111010001 (ne: 16) 0111010001 (ne: 48) 0111101000 (ne: 16) 1111101000 (ne: 144) 1011110100 (ne: 16) 0011110100 (ne: 16) 1101111010 (ne: 16) 0101111010 (ne: 144) 1110111101 (ne: 16) 0110111101 (ne: 48) 0111011110 (ne: 16) 1111011110 (ne: 48) 1011101111 (ne: 16) 0011101111 (ne: 48) 0101110111 (ne: 16) 1101110111 (ne: 80) 0010111011 (ne: 16) 1010111011 (ne: 48) 0001011101 (ne: 16) 1001011101 (ne: 48) 0000101110 (ne: 16) 1000101110 (ne: 48) 1000010111 (ne: 16) 0000010111 (ne: 144) 0100001011 (ne: 16) 1100001011 (ne: 16) 0010000101 (ne: 16) 1010000101 (ne: 144) 0001000010 (ne: 16) 1001000010 (ne: 48) 1000100001 (ne: 16) 0000100001 (ne: 48) Table 5: A basic nc-loop search, each row represents the two children of the previous chosen best case sequence. The chosen sequences are found in the left column Again we started out with a sequence of high negaperiodic energy, and very rapidly improved it. The tail length stayed shorter than the Loop in this case also. At step 1 we can see the collision between the all zero child and the all zero child with 1 bit ipped. But since we here chose negacyclic collision, the search broke out of the singularity. Finally in Table 6, we will take a look at an example of how the all zero sequence performs when using the aperiodic autocorrelation. Tail 0000000000 (ae: 285) 1000000000 (ae: 141) 1100000000 (ae: 85) 0110000000 (ae: 45) 1011000000 (ae: 29) 0101100000 (ae: 13) 18
1010110000 (ae: 13) 1101011000 (ae: 21) Loop 1110101100 (ae: 13) 0111010110 (ae: 21) 0011101011 (ae: 21) 1001110101 (ae: 29) 1100111010 (ae: 21) 1110011101 (ae: 29) 1111001110 (ae: 37) 1111100111 (ae: 45) 0111110011 (ae: 29) 1011111001 (ae: 13) 1101111100 (ae: 21) 0110111110 (ae: 21) 0011011111 (ae: 29) 1001101111 (ae: 21) 0100110111 (ae: 29) 1010011011 (ae: 37) 0101001101 (ae: 45) 0010100110 (ae: 29) 0001010011 (ae: 13) 1000101001 (ae: 21) 1100010100 (ae: 21) 0110001010 (ae: 29) 0011000101 (ae: 21) 0001100010 (ae: 29) 0000110001 (ae: 37) 0000011000 (ae: 45) 1000001100 (ae: 29) 0100000110 (ae: 13) 0010000011 (ae: 21) 1001000001 (ae: 21) 1100100000 (ae: 29) 0110010000 (ae: 21) 1011001000 (ae: 29) 0101100100 (ae: 37) 1010110010 (ae: 45) 1101011001 (ae: 29) Table 6: Basic ac loop search, using the all zero sequence of length 10 as input. The rst thing we can note is the length of the Loop, l tail = 36, not even a multiple of the sequence length n = 10. Second we note how the search hits the local minima even before entering the Loop. Even at step 6 in the tail, the energy a = 13. Once we enter the loop, energy a = 13 for the rst sequence. However thereafter there are only two occurrences of energy a = 13. The average 19
Tail Chosen Sequences Discarded Sequences 0000000000 (pe: 900) 1000000000 (pe: 324) 0000000000 (pe: 900) 1100000000 (pe: 100) 0100000000 (pe: 324) 0110000000 (pe: 100) 1110000000 (pe: 100) Loop Chosen Sequences Discarded Sequences 1011000000 (pe: 36) 0011000000 (pe: 100) 0101100000 (pe: 36) 1101100000 (pe: 68) 0010110000 (pe: 36) 1010110000 (pe: 36) 0001011000 (pe: 36) 1001011000 (pe: 36) 0000101100 (pe: 36) 1000101100 (pe: 68) 0000010110 (pe: 36) 1000010110 (pe: 100) 0000001011 (pe: 36) 1000001011 (pe: 68) 1000000101 (pe: 36) 0000000101 (pe: 100) 1100000010 (pe: 36) 0100000010 (pe: 100) 0110000001 (pe: 36) 1110000001 (pe: 196) Table 3: The full search, where we can see in each step of the search which sequences where chosen and which were discarded. The best case sequences are found in the left column energy a being signicantly higher and maximum energy a within the loop being 45, almost 3.5 times as large as the local minima. Using negacyclic collisions does not show a signicant change in structure here, so we will refrain from showing that example. 5 Analysis of the Loop Search using the All Zero Sequence We will now take a closer look at the loop search using the all zero Sequence of dierent lengths. This starting sequence was chosen because one of our goals was to look at ways to transform easily constructed sequences with high energy into more complex sequences with low Energy. 5.1 Periodic loop search, cyclic collision In Table 7 we see some loop searches using periodic energy. Searches were rst performed with the cyclic collision, then the negacyclic collision parameter. Headings are dened as follows N - sequence length tail pc - length of the tail using a pc-loop search. loop pc - length of the pc-loop, which the tail pc terminates in. 20
pmf pc - best periodic merit factor found in loop pc. coll - number of collisions found in both tail pc and loop pc. tail pn - length of the tail using a pn-loop search. loop pn - length of the pn-loop, which the tail pn terminates in. pmf pn - best periodic merit factor found in loop pn. N tail pc loop pc pmf pc coll tail pn loop pn pmf pn 10 4 10 2.776 3 6 20 2.776 11 8 11 12.100 2 9 11 4.652 12 13 12 4.500 0 13 14 13 3.840 3 11 13 3.840 14 8 14 3.768 3 23 92 3.768 15 12 15 16.070 0 16 12 16 4.000 0 17 17 17 4.514 1 13 17 4.514 18 28 18 4.764 8 14 72 4.764 19 29 19 5.468 1 21 19 3.682 20 21 20 5.000 0 21 23 21 8.480 1 36 21 5.250 22 27 22 5.760 4 49 44 5.760 23 65 23 4.482 2 41 23 5.186 24 38 24 6.000 0 25 28 25 4.594 3 27 25 4.594 26 41 26 4.120 5 46 26 6.760 27 47 27 3.344 3 55 27 5.282 28 49 28 3.500 0 29 80 29 6.006 2 89 29 4.472 30 58 30 5.000 4 105 30 7.758 31 80 31 12.32 1 87 62 6.082 32 72 32 3.368 0 33 184 33 6.186 1 132 33 6.186 34 115 34 7.048 6 102 34 3.958 35 125 35 8.390 0 36 95 36 5.062 0 37 122 37 4.96 5 102 37 6.456 38 118 38 6.810 3 152 38 5.230 39 132 39 5.106 2 91 39 4.446 40 92 40 4.760 0 Table 7: excerpt of a table comparing the dierence between cyclic and negacyclic collisions, using the all zero sequence as input for dierent lengths. If we look at the pc-loop searches, the rst thing we note is the very short pc-tail length. Considering that the all zero Sequence is a maximum energy p sequence, we expected that starting with this sequence would lead to a long tail, possibly 21
Figure 1: Comparing tail lengths of pc- and pn-loop searches, starting with the all zero sequence for lengths N = 10 to N = 1300. The two graphs are so close they are hard to dierentiate the longest tail found. However it is shown here that for sequences of short length, N < 17, most of the pc-tails are shorter then N. As we increase the sequence length N, it is easy to see that the tail length grows past N. We have to keep in mind that the total number of sequences that exists of this length grows exponentially in N. If we plot the size of the pc-tails on a graph, see Figure 1, it's very easy to see that, although the size is increasing with N, it is nowhere near achieving this kind of exponential growth. If we look at the size of the pc-loops, they seem to follow N in size. This happens because of the way doing cyclic shifts on a sequence aects the sequence's energy p. Performing any number of cyclic shift operations on a sequence will not change the energy p at all for any of the shifted sequences. This fact ensures that any time during the pc-loop search, we are faced with the following situations: When we start with the initial sequence S 0 of length N, we can already state the following facts. If we perform N cyclic shift operations on S 0, we will have t dierent sequences, where t N which all have the same Energy p, and it is highly likely that t=n. The only way during our search to prevent the above collection of sequences to form a loop is that at any point of our search, the negacyclic shifted sequence must have lower energy p than S 0. If we at any time nd a negacyclic shifted sequence that has better energy p, this sequence can now be regarded as our new S 0 and the above statements can be applied for this. 22
Figure 2: Periodic merit factors for pc-loops generated by the all zero sequence. From N = 10 to N = 1500 This shows us that for any sequence length N a pc-loop will also have a loop length of N, where all sequences in the loop are cyclic shifts of each other. This is very useful when checking for loops in our program, but this will be discussed later. However as we can see from Table 7, the periodic merit factor for the pc loops seems to come close to 6. If we take a look at Figure 2, it is very clear that the periodic merit factor converges on 7. From this graph we can draw the conclusion that starting a pc-loop search with the all zero sequence will, for longer length sequences, with high probability converge at 7. 5.2 Periodic loop search, negacyclic collision If we then look at the pn-loop searches starting with the all zero Sequence again, we see in general the same behavior as with the pc-loop searches. The tail length stays surprisingly short, although it often gives a dierent result compared to the pc-tail length, at a given N, but still grows exponentially in N. Finding that the pn-loop is very similar to the pc-loop was not a surprise, as the loops will only dier if there are one or more collisions during the search. We did not expect collisions to be common, and they are not, which we will see later on. Moreover if we look at the pn-loop lengths, we see that they are also mostly of length N. Several loops on the other hand have lengths that are a multiples of N. Examples of this happening are when N = {18, 31, 71, 75, 86}. Performing a pn-loop search starting with the all zero sequence of these lengths will yield loop lengths of {72, 62, 142, 150, 172} respectively. In terms of N these loops have lengths of {4N, 2N, 2N, 2N, 2N}. Our rst expectations of these loops was that, for the 2N-length loops, they consisted of two pc-loops that had the same energy p and at some point there was a collision and our search found a pn-loop 23
Figure 3: Graph showing the number of collisions found when performing a pc-loop search, using the all zero sequence as input for dierent lengths N. which is made up of two pc-loops. In the case where we have loop lengths of 4N, we would expect to have four pc-loops close together. While this does occur, it does not happen always. If we look at the example for periodic loops in Table 4, we can see that the pn-loop is actually made up from six dierent pc-loops. Another special case we should mention is when N = 14. In this case when we do a pn-loop search starting with the all zero Sequence we nd that the loop length = 92. This is a length of 6.571N, and shows that this particular pn-loop can not be made up of several full pc-loops.finally we'll look at the collisions. Only collisions that happened in the pc-loop search were noted. If there are no collisions, there is no need to run a pn-loop search. This is because no collisions means that both searches would be identical, as the only dierence between them is the collision handling. Looking at the above table again, we can see that there are very few collisions. In fact, although the number of sequences we traverse (tail+loop) grows fast, the number of collisions mostly stay <20. To make this even more interesting, we can see in Figure 3 that the number of collisions form a pattern depending on N. In perticular for any given sibling pair of length n (mod 4) = 0, we can eliminate the need for collision handing at all. It can also be noted experimentally, that usually the number of collisions satisfy Collisions(n(mod4) = 1) < Collisions(n(mod4) = 2) (30) Collisions(n(mod4) = 3) < Collisions(n(mod4) = 2) (31) 5.3 Negaperiodic loop search Let us see what happens if we perform the basic loop search using Energy n basic loop searches starting again with the All Zero Sequence of increasing length. 24
N - sequence length tail nc - length of the tail using a nc-loop search. loop nc - length of the nc-loop, which the tail nc terminates in. pmf nc - best negaperiodic merit factor found in loop nc. coll - number of collisions found in both tail nc and loop nc. tail nn - length of the tail using a nn-loop search. loop nn - length of the nn-loop, which the tail nn terminates in. pmf nn - best negaperiodic merit factor found in loop nn. N tail nc loop nc nmf nc coll tail nn loop nn nmf nc 10 0 1 0.416 1 6 20 6.250 11 0 1 0.366 1 8 22 4.652 12 0 1 0.326 1 14 24 6.000 13 0 1 0.294 1 13 26 3.840 14 0 1 0.268 1 12 28 8.166 15 0 1 0.246 1 24 30 7.500 16 0 1 0.228 1 15 32 4.000 17 0 1 0.212 1 33 34 5.504 18 0 1 0.198 1 21 36 3.374 19 0 1 0.186 1 41 38 5.468 20 0 1 0.174 1 32 40 10.000 21 0 1 0.164 1 59 42 5.240 22 0 1 0.156 1 35 44 4.652 23 0 1 0.148 1 60 46 4.482 24 0 1 0.142 1 47 48 3.272 25 0 1 0.134 1 59 50 4.594 26 0 1 0.120 1 49 52 3.840 27 0 1 0.124 1 65 54 4.288 28 0 1 0.108 1 65 56 5.156 29 0 1 0.114 1 104 58 6.782 30 0 1 0.110 1 135 60 10.226 31 0 1 0.106 1 81 62 5.056 32 0 1 0.102 1 105 64 6.400 33 0 1 0.098 1 111 66 5.670 34 0 1 0.096 1 128 68 6.224 35 0 1 0.092 1 129 70 6.314 36 0 1 0.090 1 144 72 5.586 37 0 1 0.088 1 118 74 4.026 38 0 1 0.084 1 142 76 7.22 39 0 1 0.082 1 168 78 6.612 40 0 1 0.080 1 141 80 5.262 Table 8: excerpt of a table comparing the dierence between cyclic and negacyclic collisions for negaperiodic energy. Using the all zero sequence as input for dierent lengths. 25
Figure 4: Graph showing the number of collisions found when performing a pc-loop search, using the all zero sequence as input for dierent lengths N. Consider Table 8. The most obvious pattern of the nc-loop search is that every single one of these terminate with the input sequence, and we have a singularity at all searches. This shows that starting with the All Zero Sequence as input in a nc-loop is a very bad choice. The problem of getting a singularity for a certain energy is that we cannot ignore collision handling. See denition of singularity. If we instead look at the nn-loop search, the same input sequences, we see that the increase in the size of the nn-tail is similar to that for the Energy p tails, although we can see from the following graph that the nn-tail length grows faster then the Energy p tails, it is nowhere near achieving exponential growth in N Changing the scale to a logarithmic, it is shown in Figure 5 the size of the tails fails to achieve exponential growth, but the predictability is very easy to see. Also for the nn-loops we can look at the merit factors. Again we see the same tendency as with Table 7. Performing nn loop searches form N = 10 to N = 1300 gives the following merit factor plot, as show in Figure 6. Comparing this plot to the plot of merit factors for pc-loops we saw previously in Figure 2, it is no doubt that the exact same pattern is emerging. In fact, we would be hard pressed to distinguish the two plots if superimposed on each other. 26
Figure 5: Identical to Figure 4, but with Y axis changed to a logarithmic scale. Figure 6: Plot of negaperiodic merit factors for nn-loop searches. N = 10 to N = 1300, all zero sequence as input. 27
5.4 Aperiodic loop search If we change our metric type to aperiodic, our search run into trouble. Again using the all zero sequence n as input, we run the search from sequence length N = 10. N tail nc loop nc mf coll tail nn loop nn mf 10 8 36 3.846 4 5 20 3.846 11 13 12 4.653 0 12 19 52 5.142 0 13 11 54 14.083 9 14 27 14.083 14 14 26 5.157 6 28 28 5.157 15 10 36 3.214 0 16 24 28 3.555 0 17 112 38 4.515 20 116 18 3.612 18 115 44 2.842 11 68 199 4.909 19 21 90 4.878 0 20 274 42 3.448 0 21 232 44 3.34 15 198 42 4.41 22 38 140 4.4 16 282 48 3.841 23 116 306 4.198 0 24 371 604 4.235 0 25 796 24 4.111 49 1090 52 3.396 26 189 30 3.976 9 286 91 4.389 27 374 52 4.733 0 28 87 32 3.698 0 29 1737 6380 6.007 439 1566 6380 6.007 30 1527 3100 4.205 200 4941 70 3.237 31 761 34 4.328 0 32 4843 31 5.12 0 33 2250 37 4.537 100 5709 74 3.093 34 11945 52204 5.504 2846 2545 1692 3.777 35 3833 82 3.46 0 36 5115 36 5.89 0 37 10648 22820 4.96 1365 15848 74 4.563 38 47180 1419 4.54 1943 2039 82 4.125 39 1244 22576 5.036 0 40 35268 45 4.545 0 41 72973 46 2.918 2785 59997 45 3.335 42 79893 14531 4.872 3469 43111 106691 5.345 43 9394 254228 5.107 0 44 19838 76208 4.699 0 45 26328 284044 5.328 10098 94459 284044 5.328 46 592860 95884 5.211 22558 92363 53360 4.66 47 110283 100 4.331 0 Table 9: excerpt of a table comparing the dierence between cyclic and negacyclic collisions for aperiodic energy. Using the all zero sequence as input for dierent lengths. 28
Figure 7: Comparison of tail and loop length for ac-loop searches, starting with the all zero sequence. If we take the results from Table 9 and plot them on a graph, we can see how the size of both the tails and loops seem to have absolutely no relation to N, Figure 7. While both the tail and loop length does seem to increase with sequence length N, it does so at highly irregular steps. For example at N = 42 the tail length has already reached 79893 and when we increase N to 43, the tail length drops to tail ac = 9394, a mere 11.76% even with increased sequence length. The same can be seen with the loop lengths, but at a much larger scale. For the ac-loop lengths in the table 9, N = {41, 45, 47}, the loop length = {46, 284044, 100}, respectively. The increase in loop length from one sequence length to the other is far beyond what we have seen in the periodic and negaperiodic loop searches above. From length N = 41 to 45, the increase in loop length is a staggering 617 386%. Only to drop again by nearly the same percentage when N = 47. This can be seen in Figure 7. Our search does not handle these extreme variations of the loop and tail length very well. It seem very unlikely that either the tail or loop lengths falls into a predictable pattern. The lack of such a pattern turns our search into one that not only must calculate a large amount of energies/merit factors, but for every new sequence found, we must backtrack the list of sequences found so far. To top o this we are also faced with the fact that when we nally do nd the loop we are not guaranteed, unlike with periodic and negaperiodic energies, that the local best energy sequence is actually within the loop. However this is something that we expected from the start. Our search does reveal some interesting data about collisions. As with the periodic search, there seem to be certain sequence lengths N where we can not nd any collisions. Whenever N = 0 (mod 4) and N = 3 (mod 4), we can see that there are no collisions, as with our periodic search above. 29
Figure 8: Number of collisions found in the searches show in Figure 7. 6 Analysis of the tail and loop sizes So far we have only looked at the tails generated by the all zero sequence and how long they are, but what does these tails look like? Is a tail simply a chain of sequences, or does it grow as a binary tree? What do the other tails connecting to the loops we have found look like? First we will study more closely at the relation between a given sequence and it's children to better understand this. 6.1 A closer look at the relation between parent and child sequences For a given sequence S 0, we generate two children sequences S 1c and S 1n by performing a right cyclic or negacyclic shift. For two child sequences S 1c and S 1n there are two (parent) sequences that can generate these children using right cyclic or negacyclic shift. One of these is S 0, and the other is a sequence identical to S 0, but with bit s n 1 negated. Let us call this sequence S' 0. The child generated by the cyclic shift of S 0 is the same sequence as that generated by a negacyclic right shift of S' 0. This change in relation will also happen for the other child. Figure 9 shows this property very clearly. Since this Figure holds for each and every sequence, we can think of the tail and loop, somehow forming a variant of the DNA double helix shape, if we include both children and the missing parent in our searches. We now put this fact into context with our search. Given the sequences S 1 and S' 1, as long as energy(s 1 ) energy(s 1) (32) then both S 0 and S' 0 will choose the same sequence as it's best case child. This is of high signicance for the structure of the tails. Looking again at the tables for 30