Oh hi!

I finally got around to doing this.Partly because I didn't have much time the last two weeks and partly because I was just lazy.

Now let's come to what I was actually going to talk about.Back when I started doing Googology (or just visiting the wiki) I thought about this function,which produces big numbers by looking at the maximum string you could make by adding every possible arrangement of different "states" of *some* macine.I'm quoting it because soon after I wrote the basics for the function I realized that you don't need actual "states" for this to work.You just need a finite amount of different....things for it to work.It's very simple and is similar to Friedman's n() function and his word puzzle.It,however,uses a different definition and is weaker.Just to note two things,I did not know about the word puzzle back then and second,because I tried to find a way to compute it(which now when I think about it is kind of wrong) and I couldn't find anything that would compute it I decided it was uncomputable.This is infact wrong.First I thought it was computable,then I thought it may not be and now I know it is.Another thing to note is I new little about how many things in Googology worked - like construction of big numbers,strong notations,large number combinatorics,computability,ect. so the definitions of this are kind of weak so remember that while ripping this apart in the comments.

Now that's out of the way,let's looked at the basics!

First we need to know the number of symbols we're using.Let's,for the sake of simplicity,say we have two symbols.We then start a chain while being aware of two things:We have to group the symbols into groups of three,so that every symbol is within a group and groups can intersect.When the symbols are added no group of three symbols should be the same as any other group.The final value for COX(n) is the longest chain you could make with end symbols.

Let's say we have our two simbols \ and /.

We start by making a chain:

\/\\/

Then we goup them:

{\/\},{/\\},{\\/}

Now,no group is the same so we continue:

\/\\//\

We group that:

{\/\},{/\\},{\\/},{\//},{//\}

As you can see,no group is the same.

We continue doing this:

\/\\//\\

We group that:

{\/\},{/\\},{\\/},{\//},{//\},{/\\}

As you can now see,the last group is the same as the second.This is illegal by the rules.So we decide to change the \ into a /.This makes \/\\//\/ and {\/\},{/\\},{\\/},{\//},{//\},{/\/} when grouped.Now,no to groups are the same again.We continue from there:

\/\\//\// produces {\/\},{/\\},{\\/},{\//},{//\},{/\/},{\//} which is illegal because the fourth and last group are the same.

\/\\//\/\ produces {\/\},{/\\},{\\/},{\//},{//\},{/\/},{\/\} which is illegal.

This is a dead end.A dead end is when there is no symbol to put at the next place so that it would be legal.So the longest string we got is 9.So it would make sence for COX(2) to be equal to 10,but there are two problems with this:

1.There are better strategies and better strings than this.The best that I've found so far is 13 and I'm pretty sure that's as long as it can get.

2.Because this function had to do with n-state machines and transitions from different states,which was later scratched (before I even made a public site) and the definitions of the COX function were changed but this remained - There had two be a start and a stop\end states to prevent it from looping forever which is not needed now,so the new COX(2) is actually COX(4) in the old version.I had left that in my site for some reason.

That's all I had to say.I added the definition and some examples,should be clear.If you have any questions please ask me!

BTW I will make a series of this,containing some of my more recent work.