analysing snr sequences - CiteSeerX

ANALYSING SNR SEQUENCES

THROUGH A SWITCHBOARD MATRIX

A Thesis

Submitted to the School of Graduate Studies and Research

in Partial Fulfillment of the

Requirements for the Degree

Master of Science

Richard Coultas

Indiana University of Pennsylvania

May 2014

ii

Indiana University of Pennsylvania School of Graduate Studies and Research

Department of Mathematics

We hereby approve the thesis of

Richard Coultas

Candidate for the degree of Master of Science ______________________ ____________________________________

Timothy B. Flowers, Ph.D. Assistant Professor of Mathematics, Advisor

____________________________________

Rick Adkins, Ph.D. Professor of Mathematics

____________________________________

Francisco E. Alarcón, Ph.D. Professor of Mathematics

ACCEPTED ___________________________________ _____________________ Timothy P. Mack, Ph.D. Dean School of Graduate Studies and Research

iii

Title: Analysing SNR Sequences Through a Switchboard Matrix

Author: Richard Coultas

Thesis Chair: Dr. Timothy B. Flowers

Thesis Committee Members: Dr. Rick Adkins

Dr. Francisco E. Alarcón

In 1960, Paul Erdös proposed the following question: what is the minimum

number of characters needed to construct an infinitely long sequence without repetition,

where repetition is defined as having two adjacent segments which are permutations of

each other [6]. Erdös provided proof that this is not possible using three characters. In

1970, P.A.B. Pleasants proved it is possible with 5 characters [7], leaving the question

of whether it is possible with four characters open until in 1992, when Veikko Keränen

found such a sequence [9]. Keränen continues to research methods of finding such

strings.

While repetition is a basic concept understood by children, analysis of non-

repetitive sequences is known to require extensive computation. The purpose of this

thesis is to develop a tool to assist in the study of non-repetitive and strongly non-

repetitive sequences. The tool uses a matrix developed from a complete vocabulary of

prime segments.

iv

ACKNOWLEDGEMENTS

First, I would like to thank the committee for working with me. I find that coming

to the table with a project in mind has led to some interesting experience for all parties,

and am thankful for their support and guidance. I would also like to thank Dr. Chrispell

for pointing me to Dr. Flowers in the first place.

I would also like to thank the National Science Foundation. If they didn’t fund

programs such as Scholarships–Creating Opportunities for Applying Mathematics (S-

COAM) at IUP and the Summer Research Program (SRP) at Randolph College, I would

not have had the opportunity to start my research or continue my studies. I wish to

extend thanks to Dr. Kuo for bringing the S-COAM program to my attention and helping

me get into the program. I also wish to extend thanks to Dr. Sheldon for establishing the

SRP.

Without Dr. Ordower at Randolph College, I would never have started looking at

repetition avoidance. His guidance in my initial research and between programs has

helped me in numerous ways. Without his support, I would never have been initiated

into this line of research.

This goes without saying, but shall be said anyways. I want to thank my family,

friends, and peers. They are always around to give me moral support. They also have

helped me get through all tough times and cheered me up when I was down. Even if

they did not fully understand what I was talking about, they listened to me. Thanks

everyone!

v

TABLE OF CONTENTS

Section Page

INTRODUCTION ............................................................................................................. 1

1. BACKGROUND .................................................................................................... 1

1.1. Definitions ...................................................................................................... 1

1.2. History ........................................................................................................... 2

1.3. Proofs ............................................................................................................ 3

1.3.1. NR Segments Over Two Characters. ................................................... 3

1.3.2. SNR Segments Over Three Characters. .............................................. 4

1.3.3. Other Related Ideas ............................................................................. 5

2. PROCESS ............................................................................................................ 6

2.1. Constructing the Matrix .................................................................................. 6

2.2. Processing Into the Matrix ............................................................................. 7

3. RESULTS ............................................................................................................. 9

3.1. The Code ..................................................................................................... 10

3.2. SNR Matrix .................................................................................................. 12

3.3. Processing Keränen’s Construction ............................................................. 14

4. CONCLUSION ................................................................................................... 19

REFERENCES .............................................................................................................. 21

APPENDICES ............................................................................................................... 22

Appendix A ......................................................................................................... 22

Appendix B ......................................................................................................... 24

Appendix C ......................................................................................................... 25

Appendix D ......................................................................................................... 28

Appendix E ......................................................................................................... 34

vi

LIST OF FIGURES

Figures Page

1 Tree of SNR segments in 3 characters .............................................................. 5

2 NR switchboard matrix ....................................................................................... 7

3 Permutations of Pleasants' construction ............................................................. 8

4 Original Pleasants' construction in NR matrix ..................................................... 8

5 CBA permutation of Pleasants' construction in NR matrix .................................. 9

6 SNR Matrix Constructor flowchart .................................................................... 10

7 Nonrepanalyzer flowchart ................................................................................. 11

8 SNRanalyzer flowchart ..................................................................................... 12

9 SNR switchboard matrix ................................................................................... 13

10 SNR matrix with reordering .............................................................................. 14

11 Keränen's original construction ........................................................................ 15

12 Permutation ABDC ........................................................................................... 16

13 Permutation ACBD ........................................................................................... 17

14 Permutation ACDB ........................................................................................... 17

15 Permutation ADBC ........................................................................................... 18

16 Permutation ADCB ........................................................................................... 19

1

INTRODUCTION

The mathematical analysis of sequences which avoid repetition was developed

throughout the 20th Century. While repetition is a basic concept understood by children,

analysis of non-repetitive sequences is known to require extensive computation. The

purpose of this thesis is to develop a new tool to assist in the analysis and investigation

of non-repetitive and strongly non-repetitive sequences. The tool makes use of a matrix

developed from a complete vocabulary of prime segments.

This thesis includes necessary background information and definitions in Section

1. Construction of the matrix and analysis with use of the matrix is illustrated for basic

non-repetitive parameters in Section 2. Pleasant’s construction is also used as a

comparative example of the process. Section 3 provides additional results

demonstrating use of the matrix with strongly non-repetitive parameters and Keränen’s

construction, along with some analysis. Indications for other uses and concluding

remarks follow in Section 4.

1. BACKGROUND. This section contains definitions of common terminology in

the study of repetition avoidance. A brief history provides an understanding of the

development of the mathematics. Proofs necessary to develop the matrix are provided

along with an explanation of how to prove a construction maintains (strongly) non-

repetitiveness.

1.1. Definitions. An alphabet is a set of characters. Characters are symbols,

such as numerals or letters. A sequence is a list of characters, where characters may

be used more than once. A segment is a subsection of a sequence. To illustrate these

concepts, let ABCBAC be a sequence using the three characters A, B, and C. BCB is a

segment of the sequence. Word and string are alternative terms for both segment and

sequence. A vocabulary is a set of words.

Since the definition of a repetition changes based on what trait in a sequence is

under analysis, it is implicitly defined by the trait instead. A sequence is considered to

be non-repetitive (NR) if it does not contain two adjacent segments that are identical to

2

each other. Square free is an alternative term found in some references to describe NR

sequences. A sequence is considered to be strongly non-repetitive (SNR) if it does not

contain two adjacent segments that are permutations of each other. Note that an SNR

sequence is inherently non-repetitive. Abelian square free is an alternative term found in

some references. To illustrate these concepts, consider the previous example,

ABCBAC. It lacks two adjacent segments that are identical to each other, so it is SN.

However, BAC is a permutation of ABC, so the sequence fails to be SNR.

Given an alphabet of n characters, a prime word is a segment composed of n-1

characters with the nth character used as the last character in the segment. A

switchboard matrix is a representation of all the possible combinations of prime words

that shows which combinations violate the desired repetition avoidance. For these

concepts to be feasible, n is restricted to the minimal number of characters necessary to

create arbitrarily long sequences that maintain the (strongly) non-repetitive trait.

There are several common terms that come up in the study of words that are not

required by this study. For example, studies have been done on palindromes, words

that is the same forwards as backwards, and overlaps, patterns where a segment’s end

is also the beginning of its repeat (as found in alfalfa). Many of these studies involve

avoiding these patterns [5].

1.2. History. Some of the earliest mathematical analysis on repetition avoidance

started at the turn of the 20th century with Axel Thue. Thue [1] uses a replacement

construction method to build an arbitrarily long non-repetitive sequence over four

characters. The replacement construction method starts with taking the characters in an

alphabet and assigning each character a segment. Then an initial segment is chosen.

Through an iterative process, each character is replaced by the assigned segment.

Since Thue, the replacement method has been the only method used in proofs for

constructing non-repetitive sequences. Sequences that result from this method are

commonly referred to as morphisms [5].

John Leech [3] is the first known case of using cyclic permutations for assigning

segments to characters. Assuming an alphabet has an order (such as 1, 2, 3), a cyclic

permutation is taking the segment of the first character and changing each character

from the segment to the next character in the alphabet to form the segment for the next

3

character. If the character is the last character in the order, it is replaced with the first

character in the order. For example, if the alphabet is {A, B, C} with alphabetical

ordering, then the cyclic permutation of a segment constructed on the alphabet would

replace A with B, replace B with C, and replace C with A. To further illustrate this

process, taking the same alphabet, if A = BCAC, then by cyclic permutation B = CABA

and C = ABCB. Cyclic permutations are used to reduce the number of calculations

needed to prove a construction produces a NR (SNR) sequence.

In 1960, Erdös proposed the following question: what is the minimum number of

characters needed to construct an infinitely long sequence without repetition, where

repetition is defined as having two adjacent segments which are permutations of each

other? The concept of SNR sequences starts with Erdös. He further provides that he

has proven it is not possible with three characters [6].

The first affirmative solution to Erdös’ question comes from Pleasants [7]. He

provides a construction for an SNR sequence using five characters and Leech’s

concept of cyclic permutations. In the same paper, Pleasants provides a construction for

an NR sequence on three characters, stating that he is not the first to achieve this task.

The only question that remained was whether it is possible to construct an SNR

sequence of infinite length using only four characters. Keränen was able to answer that

question with his construction in [9].

1.3. Proofs. The first item to prove is that there are finitely many NR segments

possible using a two character alphabet. This proof is usually left to the reader, however

this item is necessary for the NR switchboard matrix to be feasible to construct. The

next item is to prove there are finitely many SNR segments possible using a three

character alphabet for a similar reason as the previous. While Erdös claims to have

proven it in [6], he does not provide the proof. As such, the proof included was

personally attended to. Short discussions follow to explain other important topics.

1.3.1. NR Segments Over Two Characters.

Property 1: There exists a finite number of NR segments of finite length using an

alphabet of two characters.

4

Proof: Without loss of generality, let A, B be the characters in the two letter alphabet

and let all words start with the letter A. There are two options of what character can

come next. If A is chosen, then a repetition exists. That leaves B, resulting in the word

AB. Again, with two options, only A will work since B causes a repetition. The result is

ABA. The next character in the sequence must be an A or a B, however both cause a

repetition. If A is selected, the result is ABAA, which ends with A repeated. If B is

selected, the result is ABAB, which is AB repeated twice. Thus ends the proof of finite

NR words over two characters.□

This proof is simple enough that most texts do not bother writing it out. However,

it is a necessary property for the construction of prime segments in Section 2. Without

this property, there would be infinitely many prime segments which would cause the

switchboard matrix concept to be infeasible to construct.

1.3.2. SNR Segments Over Three Characters.

Property 2: There exists a finite number of SNR segments of finite length using an

alphabet of three characters.

The proof of Property 2 follows a similar logic to the proof of Property 1. Instead

of going through all the cases, a tree of possibilities is presented here.

Proof: Without loss of generality, let A, B, C be the characters of the three letter

alphabet and let all words start with the letter A. The following flow chart represents all

the sequences possible that maintain the SNR trait. The boldface A represents the

starting point and any underlined characters (A, B, C) represent the end of a segment.

Adding a character to the end of any of these sequences will create a repetition. Thus

ends the proof of finite SNR words over three characters.□

5

FIG. 1 - Tree of SNR segments in 3 characters

Notice the left branch is symmetric with the right branch in Figure 1, where all the

B’s and C’s are switched between the two branches. This quality reveals itself later in

the switchboard matrix of Section 3.

1.3.3. Other Related Ideas. There is a general means of proving a construction

produces an NR sequence of arbitrary length. Using the replacement method, the idea

is to select segments for each character that are NR. The selected segments must also

maintain NR when combined with each other. Then the construction will maintain the

NR trait as long as the preceding sequence is also NR. Since the process is iterative,

the only condition necessary to meet is that the initial sequence is NR, which is always

the case. The same idea applies to SNR sequences.

Another question that comes to mind at this point is why only prove the minimal

amount of characters needed to make infinitely long sequences? The reason is because

if such a sequence exists with an alphabet of k characters, creating a sequence with an

alphabet of k+1 characters only requires inserting the new character into the sequence

once and it maintains all the other properties of the former sequence. This simple

means of creating infinitely long NR (SNR) sequences on alphabets containing more

than minimal characters makes creating switchboard matrices for such conditions

prohibitive since the prime segments possible are infinitely many.

It should be noted that repetition avoidance is not limited to words, but also

occurs in graph theory and graph coloring. Van der Waerden’s theory is frequently

referenced in such discussions [5]. Another property that is related is additively non-

B ← C ← B ← A → C → B → C

↓ ↓ ↓ ↓ ↓ ↓

A A A A A A

↙ ↙ ↓ ↓ ↓ ↓ ↘ ↘

B B C C B B C C

↓ ↓ ↙ ↓ ↓ ↘ ↓ ↓

C A B A A C A B

↙ ↓ ↓ ↓ ↓ ↘

B A C C A B

↓ ↓ ↓ ↓

B A A C

6

repetitive (ANR) sequences. Given an alphabet where values are assigned to each

character, a sequence is ANR if no two adjacent segments of the same length add up to

the same sum. ANR sequences are inherently SNR, and thus more restrictive [8].

2. PROCESS. This section contains the process that was developed for creating

the switchboard matrix. The process is presented with the NR matrix as an example.

Processing a construction into the matrix for further analysis follows, using Pleasants’

construction to illustrate. It is assumed the alphabet in this section is {A, B, C}.

2.1. Constructing the Matrix. The matrix requires a complete vocabulary of

prime segments to be constructed. To achieve this for the NR switchboard matrix, the

segments from the proof in Section 1.3.1 are permuted to obtain the segments starting

with the character B. This increases the vocabulary from {A, AB, ABA} to also include

{B, BA, BAB}. To make all these segments fit the definition of a prime segment, the

character C is added to the end of each segment. The vocabulary that results is {AC,

BC, ABC, BAC, ABAC, BABC}.

When it comes to constructing the matrix itself, the vocabulary is placed along

the side and the top in the same order. Assuming general matrix notation, each element

in the matrix represents whether going from the ith word in the vocabulary to the jth

word in the vocabulary is legal or illegal based on the repetitions to be avoided. Since

the vocabulary is listed in the same order across the top as the side, the main diagonal

elements are automatically marked as illegal under NR. When testing whether

combinations of prime segments are legal or not, the last character of the alphabet was

placed in front of the combined segment (i.e. – C + ith word + jth word is tested in the

example). This ensures that a combination is fully tested for repetitions at the prime

level, since every segment ends with the last character of the alphabet. Using the

vocabulary as listed in the previous paragraph, the following matrix results, where X

represents an illegal combination:

7

AC BC ABC BAC ABAC BABC

AC X X X

BC X X X

ABC X X X

BAC X X X

ABAC X X X

BABC X X X

FIG. 2 - NR switchboard matrix

2.2. Processing Into the Matrix. Once the matrix is made, the construction of a

sequence may be processed into the matrix. However, there are several steps needed

to prepare the sequence for processing. The preparation of the construction is called

preprocessing. Preprocessing is composed of three parts: permuting the construction,

creating the possibilities of the construction, and spacing the possibilities. Permuting the

construction is necessary because the permutations represent the same sequence with

different labeling. As the vocabulary (and the matrix) shall remain unchanged, each

permutation of the construction has the potential to create a unique processed matrix,

as shall be demonstrated in the later. Once each permutation is made, the possibilities

under the rules of construction must be created for each permutation. Since the primary

means of constructing sequences has been the replacement method, this is only a

matter of taking each segment and pairing it with all the other segments used in the

construction (i.e. – take the segment assigned to A and attach it to all the other

segments, then repeat the process with the segment for B and so on). This provides a

complete picture of what is observable at any point in the sequence. Spacing the

possibilities is a matter of convenience. Spacing the possibilities is simply inserting a

space after the last character in the alphabet. This allows for quick identification of the

prime segments used and the order prime segments take in the construction.

To illustrate preprocessing, Pleasants’ construction from [7] is used. His

construction is

A = ABCAB

B = ACABCB

C = ACBCACB

Since there are three characters, there are six permutations of the sequence. These

permutations are detailed in Figure 3, where ABC is the original sequence.

8

Permutation A B C

ABC ABCAB ACABCB ACBCACB

BAC BCBACA BACBA BCACBCA

CBA CABACAB CACBAB CBACB

ACB ACBAC ABCBABC ABACBC

BCA BACABAC BCABC BABCAC

CAB CBCABA CBABCBA CABCA FIG. 3 - Permutations of Pleasants' construction

The next step is to create the possibilities. Following the rules of the replacement

method, the result of AB, AC, BA, BC, CA, and CB must be presented. For the sake of

brevity, only the possibilities of the original sequence is provided here.

AB = ABCABACABCB

AC = ABCABACBCACB

BA = ACABCBABCAB

BC = ACABCBACBCACB

CA = ACBCACBABCAB

CB = ACBCACBACABCB

The final step is inserting a space after every C. The resulting spacing for the above is:

AB = ABC ABAC ABC B

AC = ABC ABAC BC AC B

BA = AC ABC BABC AB

BC = AC ABC BAC BC AC B

CA = AC BC AC BABC AB

CB = AC BC AC BAC ABC B

With the information from preprocessing, processing the construction is simply checking

off all the used legal combinations. The preprocessing ensures that all the possibilities

of a construction are identified. Using the matrix built in the previous section and the

resulting information from preprocessing Pleasants’ construction, the following matrix

results where O represents a used legal combination, X represents an illegal

combination, and a blank space represents an unused legal combination:


AC X X O X O

BC O X X X

ABC X X O X O

BAC X O O X X

ABAC X O O X X

BABC X X O X

FIG. 4 - Original Pleasants' construction in NR matrix

9

Notice not every legal combination is used. In fact, only ten of the eighteen

possible combinations are used. In other words, it is not necessary for a valid

construction to utilize every legal combination. This idea is further demonstrated in the

results and discussed in the conclusion. Now if one of the permutations was processed

into the matrix, it would not be unreasonable to assume the resulting processed matrix

would be the same, but this is a false assumption as demonstrated by the result of

permutation CBA (as defined in Figure 3).


AC X X X O

BC O X X O X

ABC O X X X

BAC X O X X

ABAC X O X X

BABC X X O O X

FIG. 5 - CBA permutation of Pleasants' construction in NR matrix

Not only is the resulting matrix from permutation CBA different from the original,

but it uses only nine of the eighteen possible moves. Another property to notice in both

matrices is the symmetry with respect to the second diagonal. For the complete

processing of Pleasants’ construction, see Appendix E.

3. RESULTS. The process described in the previous section was applied to SNR

sequences and Keränen’s construction from [9]. MatLab was used to construct the

switchboard matrix, along with all images in this section. Microsoft™ Word 2010,

Microsoft™ Excel 2010, and Notepad were used in processing. It is assumed the

alphabet in this section is {A, B, C, D}.

10

3.1. The Code. The SNR Matrix Constructor builds a switchboard matrix off of

the vocabulary given to it. The program starts by creating a blank matrix, and then filling

it in. To fill in the matrix, it creates a word to be tested by the nonrepanalyzer and the

snranalyzer. The word is constructed using the last character of the alphabet, the

vocabulary word for the row, and the vocabulary word for the column (“D” + the ith word

+ the jth word). After the word is tested, the appropriate mark is made inside the matrix.

The process repeats until the matrix is completed. If efficiency is a concern and words

that fail to be NR don’t need to be segregated from words that are SNR, the

nonrepanalyzer may be removed. Also, the snranalyzer may be removed if a NR matrix

is desired instead. Figure 6 shows the flowchart of the previously described process.

FIG. 6 – SNR Matrix Constructor flowchart

11

The nonrepanalyzer takes in a word and determines if it fails to be NR. The

program starts by creating two segments and comparing them. If those segments are

the same, it ends and says there is a repetition. If they are not the same, it moves on to

the next pair of segments. For creating segments, the program starts with the first

character for the first segment, and the next character for the second segment. Then it

will test the first two characters with the second two characters. The segments continue

to be tested in this fashion until there are no more characters to expand the length of

the first segment and still have enough characters for a second segment of equal

length. Then the program starts the process over starting with the second character.

This process ensures every possible comparison is made. Once the program finishes

with comparing the last two characters with each other, it declares the word to be NR.

There are no limitations on characters used in the input. The flowchart for this program

is seen in figure 7.

FIG. 7 - Nonrepanalyzer flowchart

The snranalyzer takes a word and determines if it fails to be SNR. This program

goes through a similar process as the last program. Instead of comparing the two

segments to each other directly, it first creates tallies of how many of each character is

12

in each segment. Then it compares the tallies to each other. If the tallies are the same,

the program declares the word to not be SNR and ends. Once all the possible

comparisons are made, the word is declared SNR. The included snranalyzer is limited

to words that are composed of the characters A,B,C, and D only. Figure 8 is the

flowchart equivalent of this program.

FIG. 8 - SNRanalyzer flowchart

3.2. SNR Matrix. The vocabulary for the SNR switchboard matrix was obtained

by permuting the results from Section 1.3.2. The vocabulary is listed in the order used

for constructing the matrices in this section in Appendix B. The vocabulary contains a

total of 117 prime segments, meaning the switchboard matrix is 117x117. Since

including such a large matrix in print as the matrices were presented in Section 2 is

unreasonable, they are instead presented as 3 color images.

The MatLab code that was used to create SNR switchboard matrices is found in

Appendix A, along with the codes used to test for repetitions. There was interest in

13

finding out which combinations failed to be NR and which combinations failed to be

SNR, hence the differentiation between the two in this section. However, this

differentiation has no effect on processing constructions. As it turns out, 1041 of the

combinations failed to be NR. 8658 combinations that were NR failed to be SNR. That

leaves only 3990 combinations out of the 13689 possibilities as legal for SNR

sequences. The output of the vocabulary as listed in Appendix B is presented in Figure

9. The red blocks represent combinations that failed to be NR, the green blocks

represent the combinations that failed to be SNR, and the blue blocks represent the

legal combinations.

FIG. 9 - SNR switchboard matrix

The image clearly breaks itself down into nine sub-matrices. This is due to the

vocabulary’s alphabetical divisions, where all the segments starting with the character A

are listed first, followed by the segments starting with the character B, and finally the

segments starting with the character C. Another observation to make is that the

diagonal sub-matrices are nearly identical in structure. The remaining sub-matrices also

have similar structures. These artifacts may be explained by the symmetrical nature of

the possibilities noted in Section 1.3.2.

As an experiment, the matrix was reconstructed with a different vocabulary

ordering. The vocabulary was reordered so the segments were ordered by length first

14

and then by starting character, instead of the other way around. This new ordering was

an attempt to achieve a similar symmetry found in the NR matrix along the second

diagonal. The result is shown in Figure 10 with the same color scheme and meanings

as in Figure 9. While the symmetry over the second diagonal does not appear

attainable, the data no longer produces the sub-matrix artifacts.

FIG. 10 - SNR matrix with reordering

3.3. Processing Keränen’s Construction. Keränen’s construction uses Leech’s

cyclic permutation idea with the following string:

ABCACDCBCDCADCDBDABACABADBABCBDBCBACBCDCACB

ABDABACADCBCDCACDBCBACBCDCACDCBDCDADBDCBCA

To permute the construction, the original was turned into a numerical format using Word

and then copy-pasted while using the find and replace function to switch the numbers

with the appropriate letters. The full numerical representation is presented below.

12313432343143424121312142123242321323431321241213143234313

42321323431343243414243231

23424143414214131232423213234313432434142432312324214341424

13432434142414314121314342

34131214121321242343134324341424143141213143423431321412131

24143141213121421232421413

15

41242321232432313414241431412131214212324214134142432123242

31214212324232132343132124

Because Leech’s idea is used, the amount of preprocessing was reduced. With a four

character alphabet, twenty four permutations are possible. However, once the

permutations were reordered by character assignment, it was realized that only six

unique cases occurred. Preprocessing was finished by hand with liberal use of copy-

paste in Notepad. All twenty-four permutations are included in Appendix C while the

preprocessing results are presented in Appendix D.

After MatLab produced the matrix in Figure 9, the data was copied into Excel

where it was easier to save progress while processing by hand. The thought of

developing a program to automate the process occurred, but was deemed of lower

priority at the time. The processed matrices were then brought back into MatLab to

produce the remaining figures in this section. In the remaining figures, the red blocks

represent the illegal combinations (formerly the combinations that failed to be NR and

SNR), the green blocks represent the used legal combinations, and the blue blocks

represent the unused legal combinations.

FIG. 11 - Keränen's original construction

16

FIG. 12 - Permutation ABDC

Permutation ABDC, shown in Figure 12, is unique compared to the rest of the

permutations as it is the only sequence that does not use 67 of the 3990 legal

combinations; instead it uses only 61 of the 3990 legal combinations. Another

observation to make about all these processed matrices is the tendency of the green

blocks to lie near the boundaries of the sub-matrices. This is likely due to Keränen’s

method of constructing his sequence using shorter patterns more frequently. The

unique case permutation ABDC poses may be explained by the sudden avoidance of

the segments AD, BD, and CD combining with each other that occurs regularly with the

other permutations.

17

FIG. 13 - Permutation ACBD

As seen in Figure 13, many of the used combinations in Permutation ACBD start

with the shorter prime words that start with C or end with shorter prime words that start

with B. In Figure 14, many of the used combinations in Permutation ACDB start with the

shorter prime words that start with A or end with shorter prime words that start with C.

FIG. 14 - Permutation ACDB

18

FIG. 15 - Permutation ADBC

Figure 15 shows Permutation ADBC tended towards combinations using shorter

prime words that start with C in general. The clustering in Figure 16 suggests more of

the combinations used shorter prime words that start with B. Recalling the observation

of symmetry from Section 1.3.2, it is partially observable from the t-shaped cluster and

the scatter of data along the top of the B-row submatrices in figure 16 as compared to

those of the C-row submatrices of figure 15. These symmetries may be more easily

observed amongst the other figures if a different ordering of the vocabulary was used.

19

FIG. 16 - Permutation ADCB

4. CONCLUSION. The goal of creating the new tool was achieved, along with

demonstration of its basic usage. The SNR switchboard matrix contained several

expected qualities, such as the sub-matrices. Re-ordering the vocabulary should cause

uniform structure in the sub-matrices, which may then be used as a means of improved

storage. It is also clearly evident that Keränen’s construction does not require most of

the information provided by the matrix. The preprocessing of a construction has been

found to be a tedious task, so a possible future project would be to automate

preprocessing. The only downside of automation here is the lack of intimacy with the

construction allowing for easy observations, such as why permutation ABDC’s uses less

combinations than the others.

While the SNR switchboard matrix was successfully created, many questions are

now opened up. As noted earlier, reordering the vocabulary can drastically change the

image produced. Is there an order that is better than other orders, and in what way is it

better? Another observation that was made was that Pleasant’s construction has

symmetry along the second diagonal. Is this symmetry necessary or is it an artifact

caused by the order of the vocabulary?

Keränen [10] explains a means of suppressing unfavorable factors as he

continues his research. It is possible the switchboard matrix may be employed in his

20

research to assist in constructing sequences. The switchboard matrix would greatly

assist the project by reducing the calculations necessary to move from one step to the

next.

In the study of ANR sequences [8], observations made are what led to this study.

Now that the SNR switchboard matrix is constructed, a better means of selecting sets of

integer assignments may be developed. Another project idea that was partially explored

in this study was what properties can be imposed on sequences while maintaining the

ability to go arbitrarily long? This latter information is not documented.

Two other major projects open up with the creation of this tool. First is identifying

relevant properties of sequences. The second is a classification of sequences. A few

other related questions to these ideas come to mind. What is the minimal number of

combinations necessary to create arbitrarily long sequences? Is it possible to construct

infinitely long sequences using all the combinations? With so many questions opened

up, this new switchboard matrix will be an aid in many investigations.

21

REFERENCES

[1] A. Thue, Über unendliche Zeichenreichen, Norske Videnskabers Selskabs Skrifter, I

Mathematisch-Naturwissenschaftliche Klasse, Christiania, vol. 7, pp. 1–22, 1906.

[2] A. Thue, Über die gegenseitige Lage gleicher Teile gewisser Zeichenreihen, Norske

Videnskabers Selskabs Skrifter, I Mathematisch-Naturwissenschaftliche Klasse,

Christiania, vol. 1, pp. 1-67, 1912.

[3] J. A. Leech, A problem on strings of beads, Math Gazette 41, pp. 277-278, 1957.

[4] J. Berstel, Axel Thue’s Papers on Repetitions in Words: A Translation, vol. 20 of

Publications du LaCIM, Université du Québec a Montréal, Montreal, Quebec,

Canada, 1995.

[5] N. Rampersad and J. Shallit, Repitition in Words, Draft Version of 10 May 2012

Available online from www.academia.edu

[6] P. Erdös, Some Unsolved Problems, Magyar Tudomanyos Akademia Matematikai

Kutato Intezet Kozlemenye, 6, pp. 221-254, 1961.

[7] P. A. B. Pleasants, Non-Repetitive Sequences, in Proceedings of the Cambridge

Philosophical Society, 1968, pp. 267-275, 1970.

[8] R. Coultas, Using computers to explore non-repetitive sequences, in Proceedings of

the Annual International Conference on Technology in Collegiate Mathematics

(ICTCM ’13), pp. 67-70.

[9] V. Keränen V. Keränen, Abelian squares are avoidable on 4 letters, in Proceedings

of the Nineteenth International Colloquium on Automata, Languages and

Programming (ICALP '92), Vienna (W. Kuich, ed.), Lecture Notes in Computer

Science, 623, London: Springer-Verlag (1992) 41-52.

[10] V. Keränen, Combinatorics on words: Suppression of unfavorable factors in pattern

avoidance, The Mathematica Journal,11.Also available online at

www.mathematica-journal.com

http://www.academia.edu/

22

Appendix A. The following is the MatLab code used to construct the SNR matrix

used in the study. Figures 9 and 10 were produced directly from the results of these

programs. The flowcharts in Figures 6-8 represent what is happening in the programs.

The vocabulary was left out to reduce space used in the document and may be found in

Appendix B.

%SNR Matrix Constructor - Constructs the switchboard matrix % For strongly non-repetitive sequences.

%establish vocabulary base = [vocabulary goes here]; %set up tracking system [wrdcnt,wrdlnth]=size(base); SWITCHBOARD=zeros(wrdcnt); %constructing words & testing for i = 1:wrdcnt for j = 1:wrdcnt word=['D' deblank(base(i,:)) deblank(base(j,:))]; if (nonrepanalyzer(word) == 1) SWITCHBOARD(i,j)=2; else SWITCHBOARD(i,j)=snranalyzer(word); end end end

function SNR = snranalyzer(look) %Analyzes strings of the characters A,B,C, and D [0=SNR 1=rep] L = length(look); SNR = 0; for j = 0:L-2 for i = 2:2:L-j %Sets up segments for comparison for f = 1:i/2 str1(f)=look(f+j); str2(f)=look(i/2+f+j); end %Sets up table of counts for comparison Storage = zeros(2,4); for tally = 1:i/2 if str1(tally) == 'A' Storage(1,1)=Storage(1,1)+1; elseif str1(tally) == 'B' Storage(1,2)=Storage(1,2)+1; elseif str1(tally) == 'C' Storage(1,3)=Storage(1,3)+1; elseif str1(tally) == 'D' Storage(1,4)=Storage(1,4)+1; end if str2(tally) == 'A' Storage(2,1)=Storage(2,1)+1; elseif str2(tally) == 'B' Storage(2,2)=Storage(2,2)+1;

23

elseif str2(tally) == 'C' Storage(2,3)=Storage(2,3)+1; elseif str2(tally) == 'D' Storage(2,4)=Storage(2,4)+1; end end %Makes comparisons if (Storage(1,:) == Storage(2,:)) SNR = 1; break %end i loop if repitition is found end end clear str1 str2 %resets segments for next round if (SNR == 1) break %end j loop if repitition is found end end end

function NR = nonrepanalyzer(look) %Tests segments for repetitions [0=NR 1=rep] L = length(look); NR = 0; for j = 0:L-2 for i = 2:2:L-j for f = 1:i/2 str1(f)=look(f+j); str2(f)=look(i/2+f+j); end if (str1 == str2) NR = 1; break %end i loop if repitition is found end end clear str1 str2 %resets storage space if (NR == 1) break %end j loop if repitition is found end end end

24

Appendix B. The following is the complete vocabulary for SNR sequences in the

order used for Figures 9 and 11-16. The order follows each column from top to bottom

and then from left to right.

AD

ABD

ACD

ABAD

ABCD

ACAD

ACBD

ABACD

ABCAD

ABCBD

ACABD

ACBAD

ACBCD

ABACAD

ABACBD

ABCABD

ABCACD

ABCBAD

ACABAD

ACABCD

ACBABD

ACBACD

ACBCAD

ABACABD

ABACBAD

ABACBCD

ABCABAD

ABCBABD

ACABACD

ACABCAD

ACABCBD

ACBACAD

ACBCACD

ABACABAD

ABACBABD

ABCBABCD

ACABACAD

ACABCACD

ACBCACBD

BD

BAD

BCD

BABD

BACD

BCAD

BCBD

BABCD

BACAD

BACBD

BCABD

BCACD

BCBAD

BABCAD

BABCBD

BACABD

BACBAD

BACBCD

BCABAD

BCABCD

BCACBD

BCBABD

BCBACD

BABCABD

BABCACD

BABCBAD

BACABAD

BACBABD

BCABCBD

BCACBCD

BCBABCD

BCBACAD

BCBACBD

BABCABAD

BABCBABD

BACABACD

BCACBCAD

BCBABCBD

BCBACBCD

CD

CAD

CBD

CABD

CACD

CBAD

CBCD

CABAD

CABCD

CACBD

CBABD

CBACD

CBCAD

CABACD

CABCAD

CABCBD

CACBAD

CACBCD

CBABCD

CBACAD

CBACBD

CBCABD

CBCACD

CABACAD

CABCACD

CACBABD

CACBACD

CACBCAD

CBABCBD

CBACBCD

CBCABAD

CBCABCD

CBCACBD

CABACABD

CACBACAD

CACBCACD

CBABCBAD

CBCABCBD

CBCACBCD

25

Appendix C. The following is the full 24 sets of permuting Keränen’s

construction. The four letter designation preceding each permutation represents the

replacements of the numerical template provided earlier. Set ABCD is the original

construction.

ABCD

abcacdcbcdcadcdbdabacabadbabcbdbcbacbcdcacbabdabacadcbcdcacdbcbacbcdcacdcbdcdadbdcbca

bcdbdadcdadbadacabcbdbcbacbcdcacdcbdcdadbdcbcabcbdbadcdadbdacdcbdcdadbdadcadabacadcdb

cdacabadabacbabdbcdcacdcbdcdadbdadcadabacadcdbcdcacbadabacabdadcadabacabadbabcbdbadac

dabdbcbabcbdcbcacdadbdadcadabacabadbabcbdbadacdadbdcbabcbdbcabadbabcbdbcbacbcdcacbabd

ABDC

abdadcdbdcdacdcbcabadabacbabdbcbdbadbdcdadbabcabadacdbdcdadcbdbadbdcdadcdbcdcacbcdbda

bdcbcacdcacbacadabdbcbdbadbdcdadcdbcdcacbcdbdabdbcbacdcacbcadcdbcdcacbcacdacabadacdcb

dcadabacabadbabcbdcdadcdbcdcacbcacdacabadacdcbdcdadbacabadabcacdacabadabacbabdbcbacad

cabcbdbabdbcdbdadcacbcacdacabadabacbabdbcbacadcacbcdbabdbcbdabacbabdbcbdbadbdcdadbabc

ACBD

acbabdbcbdbadbdcdacabacadcacbcdcbcabcbdbabcacdacabadbcbdbabdcbcabcbdbabdbcdbdadcdbcba

cbdcdadbdadcadabacbcdcbcabcbdbabdbcdbdadcdbcbacbcdcadbdadcdabdbcdbdadcdadbadacabadbdc

bdabacadacabcacdcbdbabdbcdbdadcdadbadacabadbdcbdbabcadacabacdadbadacabacadcacbcdcadab

dacdcbcacbcdbcbabdadcdadbadacabacadcacbcdcadabdadcdbcacbcdcbacadcacbcdcbcabcbdbabcacd

ACDB

acdadbdcdbdabdbcbacadacabcacdcbcdcadcdbdadcacbacadabdcdbdadbcdcadcdbdadbdcbdbabcbdcda

cdbcbabdbabcabadacdcbcdcadcdbdadbdcbdbabcbdcdacdcbcabdbabcbadbdcbdbabcbabdabacadabdbc

dbadacabacadcacbcdbdadbdcbdbabcbabdabacadabdbcdbdadcabacadacbabdabacadacabcacdcbcabad

bacbcdcacdcbdcdadbabcbabdabacadacabcacdcbcabadbabcbdcacdcbcdacabcacdcbcdcadcdbdadcacb

ADBC

adbabcbdbcbacbcdcadabadacdadbdcdbdabdbcbabdadcadabacbdbcbabcdbdabdbcbabcbdcbcacdcbdba

dbcdcacbcacdacabadbdcdbdabdbcbabcbdcbcacdcbdbadbdcdacbcacdcabcbdcbcacdcacbacadabacbcd

bcabadacadabdadcdbcbabcbdcbcacdcacbacadabacbcdbcbabdacadabadcacbacadabadacdadbdcdacab

cadcdbdadbdcbdbabcacdcacbacadabadacdadbdcdacabcacdcbdadbdcdbadacdadbdcdbdabdbcbabdadc

ADCB

adcacbcdcbcabcbdbadacadabdadcdbdcdacdcbcacdadbadacabcdcbcacbdcdacdcbcacbcdbcbabdbcdca

dcbdbabcbabdabacadcdbdcdacdcbcacbcdbcbabdbcdcadcdbdabcbabdbacbcdbcbabdbabcabadacabcbd

cbacadabadacdadbdcbcacbcdbcbabdbabcabadacabcbdcbcacdabadacadbabcabadacadabdadcdbdabac

badbdcdadcdbcdcacbabdbabcabadacadabdadcdbdabacbabdbcdadcdbdcadabdadcdbdcdacdcbcacdadb

BACD





BADC





26

BCAD





BCDA





BDAC





BDCA





CABD





CADB





CBAD





CBDA





CDAB





27

CDBA





DABC





DACB





DBAC





DBCA





DCAB





DCBA





28

Appendix D. What follows are the unique preprocessed permutations. The

images resulting from this data are seen in Figures 11-16. The format of each set is the

designation, the segment assigned to each character, and the spaced version of each

possible combination of letters.

01. ORIGINAL

a = abcacdcbcdcadcdbdabacabadbabcbdbcbacbcdcacbabdabacadcbcdcacdbcbacbcdcacdcbdcdadbdcbca;

b = bcdbdadcdadbadacabcbdbcbacbcdcacdcbdcdadbdcbcabcbdbadcdadbdacdcbdcdadbdadcadabacadcdb;

c = cdacabadabacbabdbcdcacdcbdcdadbdadcadabacadcdbcdcacbadabacabdadcadabacabadbabcbdbadac;

d = dabdbcbabcbdcbcacdadbdadcadabacabadbabcbdbadacdadbdcbabcbdbcabadbabcbdbcbacbcdcacbabd;

ab = abcacd cbcd cad cd bd abacabad babcbd bcbacbcd cacbabd abacad cbcd cacd bcbacbcd cacd cbd cd ad bd

cbcabcd bd ad cd ad bad acabcbd bcbacbcd cacd cbd cd ad bd cbcabcbd badcd ad bd acd cbd cd ad bd ad cad

abacad cd b

ac = abcacd cbcd cad cd bd abacabad babcbd bcbacbcd cacbabd abacad cbcd cacd bcbacbcd cacd cbd cd ad bd

cbcacd acabad abacbabd bcd cacd cbd cd ad bd ad cad abacad cd bcd cacbad abacabd ad cad abacabad babcbd

bad ac

ad = abcacd cbcd cad cd bd abacabad babcbd bcbacbcd cacbabd abacad cbcd cacd bcbacbcd cacd cbd cd ad bd

cbcad abd bcbabcbd cbcacd ad bd ad cad abacabad babcbd bad acd ad bd cbabcbd bcabad babcbd bcbacbcd

cacbabd

ba = bcd bd ad cd ad bad acabcbd bcbacbcd cacd cbd cd ad bd cbcabcbd bad cd ad bd acd cbd cd ad bd ad cad

abacad cd babcacd cbcd cad cd bd abacabad babcbd bcbacbcd cacbabd abacad cbcd cacd bcbacbcd cacd cbd cd

ad bd cbca

bc = bcd bd ad cd ad bad acabcbd bcbacbcd cacd cbd cd ad bd cbcabcbd bad cd ad bd acd cbd cd ad bd ad cad

abacad cd bcd acabad abacbabd bcd cacd cbd cd ad bd ad cad abacad cd bcd cacbad abacabd ad cad abacabad

babcbd bad ac

bd = bcd bd ad cd ad bad acabcbd bcbacbcd cacd cbd cd ad bd cbcabcbd bad cd ad bd acd cbd cd ad bd ad cad

abacad cd bd abd bcbabcbd cbcacd ad bd ad cad abacabad babcbd bad acd ad bd cbabcbd bcabad babcbd

bcbacbcd cacbabd

ca = cd acabad abacbabd bcd cacd cbd cd ad bd ad cad abacad cd bcd cacbad abacabd ad cad abacabad babcbd

bad acabcacd cbcd cad cd bd abacabad babcbd bcbacbcd cacbabd abacad cbcd cacd bcbacbcd cacd cbd cd ad bd

cbca

cb = cd acabad abacbabd bcd cacd cbd cd ad bd ad cad abacad cd bcd cacbad abacabd ad cad abacabad babcbd

bad acbcd bd ad cd ad bad acabcbd bcbacbcd cacd cbd cd ad bd cbcabcbd bad cd ad bd acd cbd cd ad bd ad cad

abacad cd b

cd = cd acabad abacbabd bcd cacd cbd cd ad bd ad cad abacad cd bcd cacbad abacabd ad cad abacabad babcbd

bad acd abd bcbabcbd cbcacd ad bd ad cad abacabad babcbd bad acd ad bd cbabcbd bcabad babcbd bcbacbcd

cacbabd

da = d abd bcbabcbd cbcacd ad bd ad cad abacabad babcbd bad acd ad bd cbabcbd bcabad babcbd bcbacbcd

cacbabd abcacd cbcd cad cd bd abacabad babcbd bcbacbcd cacbabd abacad cbcd cacd bcbacbcd cacd cbd cd ad

bd cbca

db = d abd bcbabcbd cbcacd ad bd ad cad abacabad babcbd bad acd ad bd cbabcbd bcabad babcbd bcbacbcd

cacbabd bcd bd ad cd ad bad acabcbd bcbacbcd cacd cbd cd ad bd cbcabcbd bad cd ad bd acd cbd cd ad bd ad cad

abacad cd b

dc = d abd bcbabcbd cbcacd ad bd ad cad abacabad babcbd bad acd ad bd cbabcbd bcabad babcbd bcbacbcd

cacbabd cd acabad abacbabd bcd cacd cbd cd ad bd ad cad abacad cd bcd cacbad abacabd ad cad abacabad

babcbd bad ac

29

02.ABDC

a = abdadcdbdcdacdcbcabadabacbabdbcbdbadbdcdadbabcabadacdbdcdadcbdbadbdcdadcdbcdcacbcdbda

b = bdcbcacdcacbacadabdbcbdbadbdcdadcdbcdcacbcdbdabdbcbacdcacbcadcdbcdcacbcacdacabadacdcb

c = cabcbdbabdbcdbdadcacbcacdacabadabacbabdbcbacadcacbcdbabdbcbdabacbabdbcbdbadbdcdadbabc

d = dcadabacabadbabcbdcdadcdbcdcacbcacdacabadacdcbdcdadbacabadabcacdacabadabacbabdbcbacad

ab = abd ad cd bd cd acd cbcabad abacbabd bcbd bad bd cd ad babcabad acd bd cd ad cbd bad bd cd ad cd bcd

cacbcd bd abd cbcacd cacbacad abd bcbd bad bd cd ad cd bcd cacbcd bd abd bcbacd cacbcad cd bcd cacbcacd

acabad acd cb

ac = abd ad cd bd cd acd cbcabad abacbabd bcbd bad bd cd ad babcabad acd bd cd ad cbd bad bd cd ad cd bcd

cacbcd bd acabcbd babd bcd bd ad cacbcacd acabad abacbabd bcbacad cacbcd babd bcbd abacbabd bcbd bad bd

cd ad babc

ad = abd ad cd bd cd acd cbcabad abacbabd bcbd bad bd cd ad babcabad acd bd cd ad cbd bad bd cd ad cd bcd

cacbcd bd ad cad abacabad babcbd cd ad cd bcd cacbcacd acabad acd cbd cd ad bacabad abcacd acabad

abacbabd bcbacad

ba = bd cbcacd cacbacad abd bcbd bad bd cd ad cd bcd cacbcd bd abd bcbacd cacbcad cd bcd cacbcacd acabad

acd cbabd ad cd bd cd acd cbcabad abacbabd bcbd bad bd cd ad babcabad acd bd cd ad cbd bad bd cd ad cd bcd

cacbcd bd a

bc = bd cbcacd cacbacad abd bcbd bad bd cd ad cd bcd cacbcd bd abd bcbacd cacbcad cd bcd cacbcacd acabad

acd cbcabcbd babd bcd bd ad cacbcacd acabad abacbabd bcbacad cacbcd babd bcbd abacbabd bcbd bad bd cd ad

babc

bd = bd cbcacd cacbacad abd bcbd bad bd cd ad cd bcd cacbcd bd abd bcbacd cacbcad cd bcd cacbcacd acabad

acd cbd cad abacabad babcbd cd ad cd bcd cacbcacd acabad acd cbd cd ad bacabad abcacd acabad abacbabd

bcbacad

ca = cabcbd babd bcd bd ad cacbcacd acabad abacbabd bcbacad cacbcd babd bcbd abacbabd bcbd bad bd cd ad

babcabd ad cd bd cd acd cbcabad abacbabd bcbd bad bd cd ad babcabad acd bd cd ad cbd bad bd cd ad cd bcd

cacbcd bd a

cb = cabcbd babd bcd bd ad cacbcacd acabad abacbabd bcbacad cacbcd babd bcbd abacbabd bcbd bad bd cd ad

babcbd cbcacd cacbacad abd bcbd bad bd cd ad cd bcd cacbcd bd abd bcbacd cacbcad cd bcd cacbcacd acabad

acd cb

cd = cabcbd babd bcd bd ad cacbcacd acabad abacbabd bcbacad cacbcd babd bcbd abacbabd bcbd bad bd cd ad

babcd cad abacabad babcbd cd ad cd bcd cacbcacd acabad acd cbd cd ad bacabad abcacd acabad abacbabd

bcbacad

da = dcad abacabad babcbd cd ad cd bcd cacbcacd acabad acd cbd cd ad bacabad abcacd acabad abacbabd

bcbacad abd ad cd bd cd acd cbcabad abacbabd bcbd bad bd cd ad babcabad acd bd cd ad cbd bad bd cd ad cd

bcd cacbcd bd a

db = dcad abacabad babcbd cd ad cd bcd cacbcacd acabad acd cbd cd ad bacabad abcacd acabad abacbabd

bcbacad bd cbcacd cacbacad abd bcbd bad bd cd ad cd bcd cacbcd bd abd bcbacd cacbcad cd bcd cacbcacd

acabad acd cb

dc = dcad abacabad babcbd cd ad cd bcd cacbcacd acabad acd cbd cd ad bacabad abcacd acabad abacbabd

bcbacad cabcbd babd bcd bdad cacbcacd acabad abacbabd bcbacad cacbcd babd bcbd abacbabd bcbd bad bd cd

ad babc

30

03.ACBD

a = acbabdbcbdbadbdcdacabacadcacbcdcbcabcbdbabcacdacabadbcbdbabdcbcabcbdbabdbcdbdadcdbcba

b = bdabacadacabcacdcbdbabdbcdbdadcdadbadacabadbdcbdbabcadacabacdadbadacabacadcacbcdcadab

c = cbdcdadbdadcadabacbcdcbcabcbdbabdbcdbdadcdbcbacbcdcadbdadcdabdbcdbdadcdadbadacabadbdc

d = dacdcbcacbcdbcbabdadcdadbadacabacadcacbcdcadabdadcdbcacbcdcbacadcacbcdcbcabcbdbabcacd

ab = acbabd bcbd bad bd cd acabacad cacbcd cbcabcbd babcacd acabad bcbd babd cbcabcbd babd bcd bd ad cd

bcbabd abacad acabcacd cbd babd bcd bd ad cd ad bad acabad bd cbd babcad acabacd ad bad acabacad cacbcd

cad ab

ac = acbabd bcbd bad bd cd acabacad cacbcd cbcabcbd babcacd acabad bcbd babd cbcabcbd babd bcd bd ad cd

bcbacbd cd ad bd ad cad abacbcd cbcabcbd babd bcd bd ad cd bcbacbcd cad bd ad cd abd bcd bd ad cd ad bad

acabad bd c

ad = acbabd bcbd bad bd cd acabacad cacbcd cbcabcbd babcacd acabad bcbd babd cbcabcbd babd bcd bd ad cd

bcbad acd cbcacbcd bcbabd ad cd ad bad acabacad cacbcd cad abd ad cd bcacbcd cbacad cacbcd cbcabcbd

babcacd

ba = bd abacad acabcacd cbd babd bcd bd ad cd ad bad acabad bd cbd babcad acabacd ad bad acabacad cacbcd

cad abacbabd bcbd bad bd cd acabacad cacbcd cbcabcbd babcacd acabad bcbd babd cbcabcbd babd bcd bd ad cd

bcba

bc = bd abacad acabcacd cbd babd bcd bd ad cd ad bad acabad bd cbd babcad acabacd ad bad acabacad cacbcd

cad abcbd cd ad bd ad cad abacbcd cbcabcbd babd bcd bd ad cd bcbacbcd cad bd ad cd abd bcd bd ad cd ad bad

acabad bd c

bd = bd abacad acabcacd cbd babd bcd bd ad cd ad bad acabad bd cbd babcad acabacd ad bad acabacad cacbcd

cad abd acd cbcacbcd bcbabd ad cd ad bad acabacad cacbcd cad abd ad cd bcacbcd cbacad cacbcd cbcabcbd

babcacd

ca = cbd cd ad bd ad cad abacbcd cbcabcbd babd bcd bd ad cd bcbacbcd cad bd ad cd abd bcd bd ad cd ad bad

acabad bd cacbabd bcbd bad bd cd acabacad cacbcd cbcabcbd babcacd acabad bcbd babd cbcabcbd babd bcd bd

ad cd bcba

cb = cbd cd ad bd ad cad abacbcd cbcabcbd babd bcd bd ad cd bcbacbcd cad bd ad cd abd bcd bd ad cd ad bad

acabad bd cbd abacad acabcacd cbd babd bcd bd ad cd ad bad acabad bd cbd babcad acabacd ad bad acabacad

cacbcd cad ab

cd = cbd cd ad bd ad cad abacbcd cbcabcbd babd bcd bd ad cd bcbacbcd cad bd ad cd abd bcd bd ad cd ad bad

acabad bd cd acd cbcacbcd bcbabd ad cd ad bad acabacad cacbcd cad abd ad cd bcacbcd cbacad cacbcd

cbcabcbd babcacd

da = dacd cbcacbcd bcbabd ad cd ad bad acabacad cacbcd cad abd ad cd bcacbcd cbacad cacbcd cbcabcbd

babcacd acbabd bcbd bad bd cd acabacad cacbcd cbcabcbd babcacd acabad bcbd babd cbcabcbd babd bcd bd ad

cd bcba

db = dacd cbcacbcd bcbabd ad cd ad bad acabacad cacbcd cad abd ad cd bcacbcd cbacad cacbcd cbcabcbd

babcacd bd abacad acabcacd cbd babd bcd bd ad cd ad bad acabad bd cbd babcad acabacd ad bad acabacad

cacbcd cad ab

dc = dacd cbcacbcd bcbabd ad cd ad bad acabacad cacbcd cad abd ad cd bcacbcd cbacad cacbcd cbcabcbd

babcacd cbd cd ad bd ad cad abacbcd cbcabcbd babd bcd bd ad cd bcbacbcd cad bd ad cd abd bcd bd ad cd ad

bad acabad bd c

31

04.ACDB

a = acdadbdcdbdabdbcbacadacabcacdcbcdcadcdbdadcacbacadabdcdbdadbcdcadcdbdadbdcbdbabcbdcda

b = bacbcdcacdcbdcdadbabcbabdabacadacabcacdcbcabadbabcbdcacdcbcdacabcacdcbcdcadcdbdadcacb

c = cdbcbabdbabcabadacdcbcdcadcdbdadbdcbdbabcbdcdacdcbcabdbabcbadbdcbdbabcbabdabacadabdbc

d = dbadacabacadcacbcdbdadbdcbdbabcbabdabacadabdbcdbdadcabacadacbabdabacadacabcacdcbcabad

ab = acd ad bd cd bd abd bcbacad acabcacd cbcd cad cd bd ad cacbacad abd cd bd ad bcd cad cd bd ad bd cbd

babcbd cd abacbcd cacd cbd cd ad babcbabd abacad acabcacd cbcabad babcbd cacd cbcd acabcacd cbcd cad cd

bd ad cacb

ac = acd ad bd cd bd abd bcbacad acabcacd cbcd cad cd bd ad cacbacad abd cd bd ad bcd cad cd bd ad bd cbd

babcbd cd acd bcbabd babcabad acd cbcd cad cd bd ad bd cbd babcbd cd acd cbcabd babcbad bd cbd babcbabd

abacad abd bc

ad = acd ad bd cd bd abd bcbacad acabcacd cbcd cad cd bd ad cacbacad abd cd bd ad bcd cad cd bd ad bd cbd

babcbd cd ad bad acabacad cacbcd bd ad bd cbd babcbabd abacad abd bcd bd ad cabacad acbabd abacad

acabcacd cbcabad

ba = bacbcd cacd cbd cd ad babcbabd abacad acabcacd cbcabad babcbd cacd cbcd acabcacd cbcd cad cd bd ad

cacbacd ad bd cd bd abd bcbacad acabcacd cbcd cad cd bd ad cacbacad abd cd bd ad bcd cad cd bd ad bd cbd

babcbd cd a

bc = bacbcd cacd cbd cd ad babcbabd abacad acabcacd cbcabad babcbd cacd cbcd acabcacd cbcd cad cd bd ad

cacbcd bcbabd babcabad acd cbcd cad cd bd ad bd cbd babcbd cd acd cbcabd babcbad bd cbd babcbabd abacad

abd bc

bd = bacbcd cacd cbd cd ad babcbabd abacad acabcacd cbcabad babcbd cacd cbcd acabcacd cbcd cad cd bd ad

cacbd bad acabacad cacbcd bd ad bd cbd babcbabd abacad abd bcd bd ad cabacad acbabd abacad acabcacd

cbcabad

ca = cd bcbabd babcabad acd cbcd cad cd bd ad bd cbd babcbd cd acd cbcabd babcbad bd cbd babcbabd abacad

abd bcacd ad bd cd bd abd bcbacad acabcacd cbcd cad cd bd ad cacbacad abd cd bd ad bcd cad cd bd ad bd cbd

babcbd cd a

cb = cd bcbabd babcabad acd cbcd cad cd bd ad bd cbd babcbd cd acd cbcabd babcbad bd cbd babcbabd abacad

abd bcbacbcd cacd cbd cd ad babcbabd abacad acabcacd cbcabad babcbd cacd cbcd acabcacd cbcd cad cd bd ad

cacb

cd = cd bcbabd babcabad acd cbcd cad cd bd ad bd cbd babcbd cd acd cbcabd babcbad bd cbd babcbabd abacad

abd bcd bad acabacad cacbcd bd ad bd cbd babcbabd abacad abd bcd bd ad cabacad acbabd abacad acabcacd

cbcabad

da = d bad acabacad cacbcd bd ad bd cbd babcbabd abacad abd bcd bd ad cabacad acbabd abacad acabcacd

cbcabad acd ad bd cd bd abd bcbacad acabcacd cbcd cad cd bd ad cacbacad abd cd bd ad bcd cad cd bd ad bd cbd

babcbd cd a

db = d bad acabacad cacbcd bd ad bd cbd babcbabd abacad abd bcd bd ad cabacad acbabd abacad acabcacd

cbcabad bacbcd cacd cbd cd ad babcbabd abacad acabcacd cbcabad babcbd cacd cbcd acabcacd cbcd cad cd bd

ad cacb

dc = d bad acabacad cacbcd bd ad bd cbd babcbabd abacad abd bcd bd ad cabacad acbabd abacad acabcacd

cbcabad cd bcbabd babcabad acd cbcd cad cd bd ad bd cbd babcbd cd acd cbcabd babcbad bd cbd babcbabd

abacad abd bc

32

05.ADBC

a = adbabcbdbcbacbcdcadabadacdadbdcdbdabdbcbabdadcadabacbdbcbabcdbdabdbcbabcbdcbcacdcbdba

b = bcabadacadabdadcdbcbabcbdcbcacdcacbacadabacbcdbcbabdacadabadcacbacadabadacdadbdcdacab

c = cadcdbdadbdcbdbabcacdcacbacadabadacdadbdcdacabcacdcbdadbdcdbadacdadbdcdbdabdbcbabdadc

d = dbcdcacbcacdacabadbdcdbdabdbcbabcbdcbcacdcbdbadbdcdacbcacdcabcbdcbcacdcacbacadabacbcd

ab = ad babcbd bcbacbcd cad abad acd ad bd cd bd abd bcbabd ad cad abacbd bcbabcd bd abd bcbabcbd cbcacd

cbd babcabad acad abd ad cd bcbabcbd cbcacd cacbacad abacbcd bcbabd acad abad cacbacad abad acd ad bd cd

acab

ac = ad babcbd bcbacbcd cad abad acd ad bd cd bd abd bcbabd ad cad abacbd bcbabcd bd abd bcbabcbd cbcacd

cbd bacad cd bd ad bd cbd babcacd cacbacad abad acd ad bd cd acabcacd cbd ad bd cd bad acd ad bd cd bd abd

bcbabd ad c

ad = ad babcbd bcbacbcd cad abad acd ad bd cd bd abd bcbabd ad cad abacbd bcbabcd bd abd bcbabcbd cbcacd

cbd bad bcd cacbcacd acabad bd cd bd abd bcbabcbd cbcacd cbd bad bd cd acbcacd cabcbd cbcacd cacbacad

abacbcd

ba = bcabad acad abd ad cd bcbabcbd cbcacd cacbacad abacbcd bcbabd acad abad cacbacad abad acd ad bd cd

acabad babcbd bcbacbcd cad abad acd ad bd cd bd abd bcbabd ad cad abacbd bcbabcd bd abd bcbabcbd cbcacd

cbd ba

bc = bcabad acad abd ad cd bcbabcbd cbcacd cacbacad abacbcd bcbabd acad abad cacbacad abad acd ad bd cd

acabcad cd bd ad bd cbd babcacd cacbacad abad acd ad bd cd acabcacd cbd ad bd cd bad acd ad bd cd bd abd

bcbabd ad c

bd = bcabad acad abd ad cd bcbabcbd cbcacd cacbacad abacbcd bcbabd acad abad cacbacad abad acd ad bd cd

acabd bcd cacbcacd acabad bd cd bd abd bcbabcbd cbcacd cbd bad bd cd acbcacd cabcbd cbcacd cacbacad

abacbcd

ca = cad cd bd ad bd cbd babcacd cacbacad abad acd ad bd cd acabcacd cbd ad bd cd bad acd ad bd cd bd abd

bcbabd ad cad babcbd bcbacbcd cad abad acd ad bd cd bd abd bcbabd ad cad abacbd bcbabcd bd abd bcbabcbd

cbcacd cbd ba

cb = cad cd bd ad bd cbd babcacd cacbacad abad acd ad bd cd acabcacd cbd ad bd cd bad acd ad bd cd bd abd

bcbabd ad cbcabad acad abd ad cd bcbabcbd cbcacd cacbacad abacbcd bcbabd acad abad cacbacad abad acd ad

bd cd acab

cd = cad cd bd ad bd cbd babcacd cacbacad abad acd ad bd cd acabcacd cbd ad bd cd bad acd ad bd cd bd abd

bcbabd ad cd bcd cacbcacd acabad bd cd bd abd bcbabcbd cbcacd cbd bad bd cd acbcacd cabcbd cbcacd

cacbacad abacbcd

da = d bcd cacbcacd acabad bd cd bd abd bcbabcbd cbcacd cbd bad bd cd acbcacd cabcbd cbcacd cacbacad

abacbcd ad babcbd bcbacbcd cad abad acd ad bd cd bd abd bcbabd ad cad abacbd bcbabcd bd abd bcbabcbd

cbcacd cbd ba

db = d bcd cacbcacd acabad bd cd bd abd bcbabcbd cbcacd cbd bad bd cd acbcacd cabcbd cbcacd cacbacad

abacbcd bcabad acad abd ad cd bcbabcbd cbcacd cacbacad abacbcd bcbabd acad abad cacbacad abad acd ad bd

cd acab

dc = d bcd cacbcacd acabad bd cd bd abd bcbabcbd cbcacd cbd bad bd cd acbcacd cabcbd cbcacd cacbacad

abacbcd cad cd bd ad bd cbd babcacd cacbacad abad acd ad bd cd acabcacd cbd ad bd cd bad acd ad bd cd bd

abd bcbabd ad c

33

06.ADCB

a = adcacbcdcbcabcbdbadacadabdadcdbdcdacdcbcacdadbadacabcdcbcacbdcdacdcbcacbcdbcbabdbcdca

b = badbdcdadcdbcdcacbabdbabcabadacadabdadcdbdabacbabdbcdadcdbdcadabdadcdbdcdacdcbcacdadb

c = cbacadabadacdadbdcbcacbcdbcbabdbabcabadacabcbdcbcacdabadacadbabcabadacadabdadcdbdabac

d = dcbdbabcbabdabacadcdbdcdacdcbcacbcdbcbabdbcdcadcdbdabcbabdbacbcdbcbabdbabcabadacabcbd

ab = ad cacbcd cbcabcbd bad acad abd ad cd bd cd acd cbcacd ad bad acabcd cbcacbd cd acd cbcacbcd bcbabd

bcd cabad bd cd ad cd bcd cacbabd babcabad acad abd ad cd bd abacbabd bcd ad cd bd cad abd ad cd bd cd acd

cbcacd ad b

ac = ad cacbcd cbcabcbd bad acad abd ad cd bd cd acd cbcacd ad bad acabcd cbcacbd cd acd cbcacbcd bcbabd

bcd cacbacad abad acd ad bd cbcacbcd bcbabd babcabad acabcbd cbcacd abad acad babcabad acad abd ad cd bd

abac

ad = ad cacbcd cbcabcbd bad acad abd ad cd bd cd acd cbcacd ad bad acabcd cbcacbd cd acd cbcacbcd bcbabd

bcd cad cbd babcbabd abacad cd bd cd acd cbcacbcd bcbabd bcd cad cd bd abcbabd bacbcd bcbabd babcabad

acabcbd

ba = bad bd cd ad cd bcd cacbabd babcabad acad abd ad cd bd abacbabd bcd ad cd bd cad abd ad cd bd cd acd

cbcacd ad bad cacbcd cbcabcbd bad acad abd ad cd bd cd acd cbcacd ad bad acabcd cbcacbd cd acd cbcacbcd

bcbabd bcd ca

bc = bad bd cd ad cd bcd cacbabd babcabad acad abd ad cd bd abacbabd bcd ad cd bd cad abd ad cd bd cd acd

cbcacd ad bcbacad abad acd ad bd cbcacbcd bcbabd babcabad acabcbd cbcacd abad acad babcabad acad abd ad

cd bd abac

bd = bad bd cd ad cd bcd cacbabd babcabad acad abd ad cd bd abacbabd bcd ad cd bd cad abd ad cd bd cd acd

cbcacd ad bd cbd babcbabd abacad cd bd cd acd cbcacbcd bcbabd bcd cad cd bd abcbabd bacbcd bcbabd

babcabad acabcbd

ca = cbacad abad acd ad bd cbcacbcd bcbabd babcabad acabcbd cbcacd abad acad babcabad acad abd ad cd bd

abacad cacbcd cbcabcbd bad acad abd ad cd bd cd acd cbcacd ad bad acabcd cbcacbd cd acd cbcacbcd bcbabd

bcd ca

cb = cbacad abad acd ad bd cbcacbcd bcbabd babcabad acabcbd cbcacd abad acad babcabad acad abd ad cd bd

abacbad bd cd ad cd bcd cacbabd babcabad acad abd ad cd bd abacbabd bcd ad cd bd cad abd ad cd bd cd acd

cbcacd ad b

cd = cbacad abad acd ad bd cbcacbcd bcbabd babcabad acabcbd cbcacd abad acad babcabad acad abd ad cd bd

abacd cbd babcbabd abacad cd bd cd acd cbcacbcd bcbabd bcd cad cd bd abcbabd bacbcd bcbabd babcabad

acabcbd

da = d cbd babcbabd abacad cd bd cd acd cbcacbcd bcbabd bcdcad cd bd abcbabd bacbcd bcbabd babcabad

acabcbd ad cacbcd cbcabcbd bad acad abd ad cd bd cd acd cbcacd ad bad acabcd cbcacbd cd acd cbcacbcd

bcbabd bcd ca

db = d cbd babcbabd abacad cd bd cd acd cbcacbcd bcbabd bcdcad cd bd abcbabd bacbcd bcbabd babcabad

acabcbd bad bd cd ad cd bcd cacbabd babcabad acad abd ad cd bd abacbabd bcd ad cd bd cad abd ad cd bd cd

acd cbcacd ad b

dc = d cbd babcbabd abacad cd bd cd acd cbcacbcd bcbabd bcdcad cd bd abcbabd bacbcd bcbabd babcabad

acabcbd cbacad abad acd ad bd cbcacbcd bcbabd babcabad acabcbd cbcacd abad acad babcabad acad abd ad cd

bd abac

34

Appendix E. The following is the full precursory study with Pleasant’s

construction. The title of each section represents the permutation used. Then the

character assignments follow, with the spaced combinations afterwards. Last in each

part is a matrix representation of the permutation, where xs are illegal combinations and

os are used legal combinations. The empty spaces are unused legal permutations. The

numbers that follow each matrix are the number of legal combinations used out of the

total available. Figures 4 and 5 relate to 1. Original and 3. AC respectively.

1. ORIGINAL

a=abcab

b=acabcb

c=acbcacb

ab=-abc abac abc b-

ac=-abc abac bc ac b-

ba=-ac abc babc ab-

bc=-ac abc bac bc ac b-

ca=-ac bc ac babc ab-

cb=-ac bc ac bac abc b-

x x o x o ac

o x x x bc

x x o x o abc

x o o x x bac

x o o x x abac

x x o x babc

10/18

2. AB

a=bcbaca

b=bacba

c=bcacbca

ab=-bc bac abac ba-

ac=-bc bac abc ac bc a-

ba=-bac babc bac a-

bc=-bac babc ac bc a-

ca=-bc ac bc abc bac a-

cb=-bc ac bc abac ba-

x o x x ac

x o x o x bc

o x x o x abc

x o x o x bac

x x x o abac

o x x o x babc

10/18

3. AC

a=cabacab

b=cacbab

c=cbacb

ab=-c abac abc ac bab-

ac=-c abac abc bac b-

ba=-c ac babc abac ab-

bc=-c ac babc bac b-

ca=-c bac bc abac ab-

cb=-c bac bc ac bab-

x x x o ac

o x x o x bc

o x x o x abc

x o x x bac

x o x x abac

x x o o x babc

09/18

35

4. BC

a=acbac

b=abcbabc

c=abacbc

ab=-ac bac abc babc-

ac=-ac bac abac bc-

ba=-abc babc ac bac-

bc=-abc babc abac bc-

ca=-abac bc ac bac-

cb=-abac bc abc babc-

x x o x ac

o x o x x bc

x x x o abc

x o x o x bac

x o x x abac

o x x o x babc

09/18

5. ABC

a=bacabac

b=bcabc

c=babcac

ab=-bac abac bc abc-

ac=-bac abac babc ac-

ba=-bc abc bac abac-

bc=-bc abc babc ac-

ca=-babc ac bac abac-

cb=-babc ac bc abc-

x o x o x ac

x o x x bc

x x o x o abc

x x o x bac

x o x x o abac

o x x x babc

09/18

6. ACB

a=cbcaba

b=cbabcba

c=cabca

ab=-c bc abac babc ba-

ac=-c bc abac abc a-

ba=-c babc bac bc aba-

bc=-c babc bac abc a-

ca=-c abc ac bc aba-

cb=-c abc ac babc ba-

x o x x o ac

x x o x bc

o x x x abc

x o o x x bac

x o x x o abac

x x o x babc 09/18

analysing snr sequences - CiteSeerX

Documents

Transcript of analysing snr sequences - CiteSeerX