meditationatae

Just another WordPress.com site

C source code to current TM #4 (chaotic) simulator

The code compiles and executes without problems using the GCC compiler on architecture x86_64 on Linux.

It only needs the standard C library. It’s an accelerated simulator that combines many repated operations into one big operation. It was checked against a conventional un-accelerated TM simulator, and the outputs matched.

(no name program, or sim12g84.c locally):

=========================================================

 

#include <stdio.h>
#define STACK_HEIGHT 100000000
#define TMAX 10

 

long lstack[STACK_HEIGHT]; // pile gauche; pas de malloc ou calloc
long rstack[STACK_HEIGHT]; // pile droite; “” “” “”

int main(void)
{

long ltop; // le sommet de la pile gauche; ltop est un indice
long rtop; // sommet de pile droite
int p1, p2, p3; // variables essentiellement booleennes
long time;
long time_billions;
long current_block; // nombre de 0 ou de 1 consecutifs dans le bloc sous la
long subindex; // tete de lecture; subindex indique ou la tete est
long loop_counter;
long loop_counter_b;
long delta_time;
long num1, num2, num9;
long count_ones;
long i;
int done;
int state; // 1->A, 2->B, 3->C
int the_rule; // meta-regle: de 1 a 10

 

ltop = 1;
rtop = 1;
lstack[1] = 3;
rstack[1] = 2;
current_block = 4; // au debut: 2000000000, 3, *4*, 2, 2000000000
subindex = 1; // nombre de 0 consecutifs, 1 consec., 0 consec., 1 consec., 0 consec.
time = 38; // on debute au temps 38
time_billions = 0;
state = 1; // on debute dans l’etat A
done = 0; // si 0: pas encore termine; si 1: on doit stopper le programme
loop_counter = 0;
loop_counter_b = 0;

 

while(done == 0)
{

 

if(1==0)
{
done = 1; // depasse le temps 10^10, on va stopper le programme
}

 

 

 

if( loop_counter>104)
{

if(the_rule == 10)
{
//printf(“a”);
}
else
{

if(the_rule == 1)
{
//printf(“\n”);
}

//printf(“%d”,the_rule);
}
} // le bloc de code C precedant concerne juste ce qui sera affiche

 

 

lstack[0] = 2000000000; // on pretend qu’il y a 2000000000 de zeros consec.
// a gauche, au debut de la pile; 2e+9 remplace l’infini

rstack[0] = 2000000000;

if(done == 1)
{
break; // porte de sortie de la boucle while(done == 0)
}

if(state == 1) // etat present = A
{
p1=0; // p1, p2, p3 sont des booleennes
p2=0; // avec des affectations qui varient selon l’etat
p3=0; // c’est pour economiser les noms de variable

if(subindex == 1)
{
p1 = 1;
}

if(lstack[ltop-1]==3 && lstack[ltop]==3)
{
p2 = 1;
}

if(lstack[ltop-1] > 7)
{
p3 = 1;
}

if(p1==1 && p2==0 && p3==1)
{
the_rule = 1; // the_rule := numero de la meta-regle a appliquer
}

if(p1==1 && p2==0 && p3==0)
{
the_rule = 5;
}

if(p1==1 && p2==1)
{
the_rule = 6;
}

if(p1 == 0)
{
the_rule = 8;
}
}

if(state == 2) // etat present = B
{
p1 = 0;
p2 = 0;

if(rstack[rtop-1] > 1)
{
p1 = 1;
}

if( (rstack[rtop]%2) == 0)
{
p2 = 1;
}

if(p1==0)
{
the_rule = 2;
}

if(p1==1 && p2==1)
{
the_rule = 3;
}

if(p1==1 && p2==0)
{
the_rule = 4;
}

}

if(state == 3) // etat present = C
{
p1 = 0;
p2 = 0;

if(subindex == 1)
{
p1 = 1;
}

if(current_block > 2)
{
p2 = 1;
}

if(p1 == 0)
{
the_rule = 7;
}

if(p1 == 1 && p2 == 1)
{
the_rule = 9;
}

if(p1==1 && p2==0)
{
the_rule = 10;
}

}

/*** le numero de la meta-regle est maintenant connu;
il s’agit ensuite de l’appliquer;
c’est le role du switch(the_rule) plus bas avec les “case” ***/

switch(the_rule)
{
case 1:
rstack[rtop] = 2+rstack[rtop];
lstack[ltop-1]=lstack[ltop-1]-8;
ltop=ltop+2;
lstack[ltop]=5;
lstack[ltop-1]=1;
subindex=4;
state=2;
delta_time=103;
break;

case 2:
num1=rstack[rtop];
num2=rstack[rtop-2];
current_block = current_block – 1;
rstack[rtop]=rstack[rtop]+1;
rstack[rtop-4]=rstack[rtop-4]+2;
ltop=ltop+2; // pile gauche “gagne 2 elements”
lstack[ltop]=rstack[rtop];
lstack[ltop-1]=current_block;
rtop=rtop-4; // la pile de droite “perd 4 elements”
current_block=num2;
subindex=num2;
state=2; // le prochain etat va etre B, apres application de Rule 2
delta_time=3*num1 + num2 + 4; // temps a ajouter au compteur de temps
break;

/*** dans la meta-regle 2, il y a une amalgation de blocs
suite a l’application de la meta-regle **/

case 3:
subindex=subindex-1;
current_block = current_block + 2;
rstack[rtop-1]=rstack[rtop-1]-2;
state=1;
delta_time = 7*rstack[rtop] – 1;
break;

case 4:
num1=rstack[rtop];
current_block=current_block+1;
rstack[rtop]=rstack[rtop]+1;
rstack[rtop-1]=rstack[rtop-1]-2;
subindex=subindex-1;
state=3;
delta_time = 7*num1 + 2;
break;

case 5:
current_block=current_block-1;
lstack[ltop]=lstack[ltop]-2;
rtop=rtop+2; // le sommet de pile droite croit de 2 blocs
rstack[rtop]=1;
rstack[rtop-1]=current_block;
current_block=2;
state=3;
delta_time=6;
break;

/*** case 5: ltop est inchange, rtop augmente de 2: cas de fission de blocs
apres application de la regle; inverse d’une amalgamation ***/

 

case 6:
subindex=2;
lstack[ltop-1]=lstack[ltop-1]-1;
current_block=current_block-1;
rtop=rtop+4;
rstack[rtop]=1;
rstack[rtop-1]=3;
rstack[rtop-2]=1;
rstack[rtop-3]=current_block;
current_block=lstack[ltop-1];
ltop=ltop-2;
state=2;
delta_time=5;
break;

case 7:
current_block=current_block-3;
subindex=subindex-1;
rtop=rtop+2;
rstack[rtop]=2;
rstack[rtop-1]=1;
state=2;
delta_time=3;
break;

case 8:
subindex=subindex-2;
current_block=current_block-3;
rtop=rtop+2;
rstack[rtop]=2;
rstack[rtop-1]=1;
state=3;
delta_time=10;
break;

case 9:
num9=lstack[ltop];
current_block=current_block-2;
lstack[ltop]=lstack[ltop]-1;
lstack[ltop-1]=lstack[ltop-1]+3;
subindex=lstack[ltop-1]-3;
rtop=rtop+2;
rstack[rtop-1]=current_block;
rstack[rtop]=lstack[ltop];
current_block=lstack[ltop-1];
ltop=ltop-2;
state=1;
delta_time= 4*num9 – 6;
break;

case 10:
num9=lstack[ltop];
current_block=current_block-2;
lstack[ltop]=lstack[ltop]-1;
lstack[ltop-1]=lstack[ltop-1]+3;
subindex=lstack[ltop-1]-3;
rstack[rtop]=rstack[rtop]+lstack[ltop];
current_block=lstack[ltop-1];
ltop=ltop-2;
state=1;
delta_time=4*num9 – 6;
break;

}

 

time = time + delta_time; // ajustement du nombre de steps ecoules
// un step est une transition selon la table

 

while(time >= 1000000000) // pour s’occuper de l’overflow de “time”
{
time = time – 1000000000;
time_billions++;
}

/****************

 

TIME IS: 8 billion + 914287753
USING RULE 1
ltop = 4611
rtop = 1673

1222

498722222
498722222
498722222
498722222
498722222
498722222
498722222
498722222
498722222
498722222

4987222
49896495a89
TIME IS: 8 billion + 914314687
USING RULE 1
ltop = 4691
rtop = 1533

 

*******************/

 

if(rtop == 1 && the_rule ==3 &&(3==(ltop%701)) )
{

/*** if rtop=1 and the_rule=3, then the head seems to
always be over square 0 July 18, 2006 ***/

 

count_ones=0;

i=1; // plus petit indice pointant a un bloc de 1 consecutifs

while(i<=ltop)
{
count_ones = count_ones + lstack[i];
i=i+2;
}

 

i=1;

if( time_billions > 455000)
{

while(i<=ltop)
{
printf(“%d “, lstack[i]);
i=i+1;
}

}

 

 

 

 

 

i=1;

while(i<=rtop)
{
count_ones = count_ones + rstack[i];
i=i+2;
}

 

printf(“\n”);

 

printf(“TIME IS: %ld billion + %ld\n”,time_billions, time);
printf(“COUNT OF ONES IS: %ld\n”, count_ones);

printf(“USING RULE %d\n”, the_rule);
printf(“ltop = %ld\n”, ltop);
printf(“rtop = %ld\n”, rtop);
printf(“counter= %ld billion + %ld\n”,loop_counter_b, loop_counter);

 

}

loop_counter++;
while(loop_counter>=1000000000)
{
loop_counter= loop_counter-1000000000;
loop_counter_b++;
}

 

} // ferme l’accoade de while(done == 0)

return 0;

} // ferme l’accoade de main()

Advertisements

Written by meditationatae

September 20, 2017 at 5:06 am

Posted in History

Patterns in the b’-numbers related to TM #4 (chaotic) presumptive sequence

Patterns in the b’-numbers related to TM #4 (chaotic) presumptive sequence

 

b’ numbers =

((( {1, 2, 3, 4, 5, 6, 7}

Union the following disjoint sets,
one per number of bits in the base 2
representations of these numbers,
4 bits for v8,
5 bits for v16,
6 bits for v32,
7 bits for v64,
8 bits for v128,
9 bits for v256,
10 bits for v512,
11 bits for v1024
and so on.
)))

What I noticed is that
if we subtract 128 from the 16 numbers in v128, then we get
the first 16 numbers of “v256 minus 256”, which has 23 numbers.

In other words, the offsets from 16 in [17, 18, 19, 22, 26]
give the 5 first terms in the offsets from 32 in [33, 34, 35, 38, 42, 50],
and so on for higher powers of 2.

The v8 through v1024 finite sequences :

 

? v8
%225 = [9, 10, 11, 14]

 

? v16
%226 = [17, 18, 19, 22, 26]

 

? v32
%227 = [33, 34, 35, 38, 42, 50]

 

? v64
%228 = [65, 66, 67, 70, 74, 82, 97, 99, 102, 106]

 

? v128
%229 = [129, 130, 131, 134, 138, 146, 161, 163, 166, 170, 193, 195, 198, 202, 227, 234]

 

? v256
%230 = [257, 258, 259, 262, 266, 274, 289, 291, 294, 298, 321, 323, 326, 330, 355, 362, 386, 402, 417, 422, 451, 458, 483]

 

? v512
%231 = [513, 514, 515, 518, 522, 530, 545, 547, 550, 554, 577, 579, 582, 586, 611, 618, 642, 658, 673, 678, 707, 714, 739, 769, 771, 774, 778, 803, 810, 833, 838, 874, 934, 970, 995]

 

? v1024
%232 = [1025, 1026, 1027, 1030, 1034, 1042, 1057, 1059, 1062, 1066, 1089, 1091, 1094, 1098, 1123, 1130, 1154, 1170, 1185, 1190, 1219, 1226, 1251, 1281, 1283, 1286, 1290, 1315, 1322, 1345, 1350, 1386, 1446, 1482, 1507, 1538, 1554, 1569, 1574, 1603, 1610, 1635, 1666, 1682, 1697, 1731, 1795, 1802, 1827, 1862, 1958, 1994]

 

===============

Checking the property:

? for(X=1, c8, print(v8[X]-8))
1
2
3
6
?
? for(X=1, c16, print(v16[X]-16))
1
2
3
6
10
?
? for(X=1, c32, print(v32[X]-32))
1
2
3
6
10
18
?
? for(X=1, c64, print(v64[X]-64))
1
2
3
6
10
18
33
35
38
42
?
? for(X=1, c128, print(v128[X]-128))
1
2
3
6
10
18
33
35
38
42
65
67
70
74
99
106
?
? for(X=1, c256, print(v256[X]-256))
1
2
3
6
10
18
33
35
38
42
65
67
70
74
99
106
130
146
161
166
195
202
227
?
? for(X=1, c512, print(v512[X]-512))
1
2
3
6
10
18
33
35
38
42
65
67
70
74
99
106
130
146
161
166
195
202
227
257
259
262
266
291
298
321
326
362
422
458
483
?
? for(X=1, c1024, print(v1024[X]-1024))
1
2
3
6
10
18
33
35
38
42
65
67
70
74
99
106
130
146
161
166
195
202
227
257
259
262
266
291
298
321
326
362
422
458
483
514
530
545
550
579
586
611
642
658
673
707
771
778
803
838
934
970

==================================

A sequence of offsets:

{1, 2, 3, 6, 10, 18, 33, 35, 38, 42, 65, 67, 70, 74, 99, 106}

would be the first 16 terms in a hypothetically infinite
sequence of offsets.

Sloane’s Online Encyclopedia of Integer Sequences has nothing
for:

1, 2, 3, 6, 10, 18, 33

“Sorry, but the terms do not match anything in the table.”
is the reply.

Can we crack the sequence of offsets?

I’m not so sure.

 

Written by meditationatae

September 20, 2017 at 3:23 am

Posted in History

b'(n) sequence in binary, n = 1 to 158:

? for(X=1,158, print(binary(yyy[X]) ))
[1]
[1, 0]
[1, 1]
[1, 0, 0]
[1, 0, 1]
[1, 1, 0]
[1, 1, 1]
[1, 0, 0, 1]
[1, 0, 1, 0]
[1, 0, 1, 1]
[1, 1, 1, 0]
[1, 0, 0, 0, 1]
[1, 0, 0, 1, 0]
[1, 0, 0, 1, 1]
[1, 0, 1, 1, 0]
[1, 1, 0, 1, 0]
[1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 1, 1]
[1, 0, 0, 1, 1, 0]
[1, 0, 1, 0, 1, 0]
[1, 1, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 1, 0, 1, 0]
[1, 0, 1, 0, 0, 1, 0]
[1, 1, 0, 0, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 1, 1, 0]
[1, 1, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 1, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 1, 0, 1, 0, 1, 0]
[1, 1, 0, 0, 0, 0, 0, 1]
[1, 1, 0, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 1, 1, 0]
[1, 1, 0, 0, 1, 0, 1, 0]
[1, 1, 1, 0, 0, 0, 1, 1]
[1, 1, 1, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 1, 0, 0, 1, 0]
[1, 0, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 0, 1, 0, 1, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 0, 1, 1, 0]
[1, 0, 1, 0, 0, 1, 0, 1, 0]
[1, 0, 1, 1, 0, 0, 0, 1, 1]
[1, 0, 1, 1, 0, 1, 0, 1, 0]
[1, 1, 0, 0, 0, 0, 0, 1, 0]
[1, 1, 0, 0, 1, 0, 0, 1, 0]
[1, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 1, 0, 1, 0, 0, 1, 1, 0]
[1, 1, 1, 0, 0, 0, 0, 1, 1]
[1, 1, 1, 0, 0, 1, 0, 1, 0]
[1, 1, 1, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 0, 1, 0, 0, 1, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 1, 0, 1, 0, 1, 0]
[1, 0, 0, 1, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 1, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 1, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 1, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 1, 1, 0, 1, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 1, 0, 0, 1, 0]
[1, 0, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 1, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 1, 1, 0, 0, 1, 0, 1, 0]
[1, 0, 1, 1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 1, 0, 0, 0, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 0, 1, 1, 0]
[1, 1, 0, 0, 0, 0, 1, 0, 1, 0]
[1, 1, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 1, 0, 1, 0, 1, 0]
[1, 1, 0, 1, 0, 0, 0, 0, 0, 1]
[1, 1, 0, 1, 0, 0, 0, 1, 1, 0]
[1, 1, 0, 1, 1, 0, 1, 0, 1, 0]
[1, 1, 1, 0, 1, 0, 0, 1, 1, 0]
[1, 1, 1, 1, 0, 0, 1, 0, 1, 0]
[1, 1, 1, 1, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0]
[1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0]
[1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]
[1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0]
[1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0]
[1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0]
[1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0]
[1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0]
[1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0]
[1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0]
[1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0]
[1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0]
[1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0]
[1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]
[1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0]
[1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1]
[1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1]
[1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0]
[1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0]
[1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0]
[1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0]

Written by meditationatae

September 19, 2017 at 12:09 am

Posted in History

Irregular sequence derived from the b-numbers

If the n’th b-number is b(n), then b(n) == 3 (mod 8).

Therefore, b(n)+5 is divisible by 8, and we can form:

b'(n) := ( b(n) + 5)/8. For n = 1, 2, 3, …

we have b'(n) as copied below, an irregular sequence:

1
2
3
4
5
6
7
9
10
11
14
17
18
19
22
26
33
34
35
38
42
50
65
66
67
70
74
82
97
99
102
106
129
130
131
134
138
146
161
163
166
170
193
195
198
202
227
234
257
258
259
262
266
274
289
291
294
298
321
323
326
330
355
362
386
402
417
422
451
458
483
513
514
515
518
522
530
545
547
550
554
577
579
582
586
611
618
642
658
673
678
707
714
739
769
771
774
778
803
810
833
838
874
934
970
995
1025
1026
1027
1030
1034
1042
1057
1059
1062
1066
1089
1091
1094
1098
1123
1130
1154
1170
1185
1190
1219
1226
1251
1281
1283
1286
1290
1315
1322
1345
1350
1386
1446
1482
1507
1538
1554
1569
1574
1603
1610
1635
1666
1682
1697
1731
1795
1802
1827
1862
1958
1994

etc.

 

Written by meditationatae

September 18, 2017 at 10:23 pm

Posted in History

The sequence of “b-numbers” determines some values in Column 3 of the TM #4 presumptive sequence

For a b-number ‘b’ ,

empirically,

s(2^m – b – 2) = 2^m – b, as long as
b > 0 (always true) AND
b < 2^(m-1).

Being connected to Column 3 of 8,
a “b-number” b is such that b == 3 (mod 8).

A b-number ‘b’ predicts relationships
of the type:
s(y) = y+2, where y == 3 (mod 8).
So, y+2 == 5 (mod 8), and
2^m – b = y+2 == 5 (mod 8).

Suppose m >= 3, which I think is
always the case, then 2^m == 0 (mod 8),
so -b == 5 (mod 8), so
b == -5 (mod 8) or
b == 3 (mod 8).

 

For m = 3, 2^m = 8. If b = 3, then
3 < 2^(3-1).

It predicts:

s(8-3-2) = 8-3 i.e.
s(3) = 5.

s sequence is: 3, 1, 5, etc. so s(3) = 5 check Ok.

The s-sequence comes from the run-length encoding
of ‘0’ and ‘1’ symbols at special times, in the
evolution of TM #4, “chaotic”, of Heiner Marxen
and Buntrock, found around 1990, and that exhibits
a seemingly chaotic or random behavior.

 

 

For generation number “x”,
the “b-number” ‘b’ has an ancestor
from an earlier generation that is obtained by
subtracting 2^(x-1) from ‘b’.

Example:

b = 555
generation = x = 10

rule: 2^(x-1) = 2^9 = 512
and b – 2^(x-1) =
= 555 – 512 = 43.

43 is the ancestor of 555.

Is 43 in the sequence of b-numbers ?

Yes, from generation 6.

 

Below, b-numbers below 2^14 = 16384:

 

b-number, generation, “ancestor”
===================================
3 2 1

 

11 4 3

 

19 5 3
27 5 11

 

35 6 3
43 6 11
51 6 19

 

67 7 3
75 7 11
83 7 19
107 7 43

 

131 8 3
139 8 11
147 8 19
171 8 43
203 8 75

 

259 9 3
267 9 11
275 9 19
299 9 43
331 9 75
395 9 139

 

515 10 3
523 10 11
531 10 19
555 10 43
587 10 75
651 10 139
771 10 259
787 10 275
811 10 299
843 10 331

 

1027 11 3
1035 11 11
1043 11 19
1067 11 43
1099 11 75
1163 11 139
1283 11 259
1299 11 275
1323 11 299
1355 11 331
1539 11 515
1555 11 531
1579 11 555
1611 11 587
1811 11 787
1867 11 843

 

2051 12 3
2059 12 11
2067 12 19
2091 12 43
2123 12 75
2187 12 139
2307 12 259
2323 12 275
2347 12 299
2379 12 331
2563 12 515
2579 12 531
2603 12 555
2635 12 587
2835 12 787
2891 12 843
3083 12 1035
3211 12 1163
3331 12 1283
3371 12 1323
3603 12 1555
3659 12 1611
3859 12 1811

 

4099 13 3
4107 13 11
4115 13 19
4139 13 43
4171 13 75
4235 13 139
4355 13 259
4371 13 275
4395 13 299
4427 13 331
4611 13 515
4627 13 531
4651 13 555
4683 13 587
4883 13 787
4939 13 843
5131 13 1035
5259 13 1163
5379 13 1283
5419 13 1323
5651 13 1555
5707 13 1611
5907 13 1811
6147 13 2051
6163 13 2067
6187 13 2091
6219 13 2123
6419 13 2323
6475 13 2379
6659 13 2563
6699 13 2603
6987 13 2891
7467 13 3371
7755 13 3659
7955 13 3859

 

8195 14 3
8203 14 11
8211 14 19
8235 14 43
8267 14 75
8331 14 139
8451 14 259
8467 14 275
8491 14 299
8523 14 331
8707 14 515
8723 14 531
8747 14 555
8779 14 587
8979 14 787
9035 14 843
9227 14 1035
9355 14 1163
9475 14 1283
9515 14 1323
9747 14 1555
9803 14 1611
10003 14 1811
10243 14 2051
10259 14 2067
10283 14 2091
10315 14 2123
10515 14 2323
10571 14 2379
10755 14 2563
10795 14 2603
11083 14 2891
11563 14 3371
11851 14 3659
12051 14 3859
12299 14 4107
12427 14 4235
12547 14 4355
12587 14 4395
12819 14 4627
12875 14 4683
13075 14 4883
13323 14 5131
13451 14 5259
13571 14 5379
13843 14 5651
14355 14 6163
14411 14 6219
14611 14 6419
14891 14 6699
15659 14 7467
15947 14 7755

 

Written by meditationatae

September 18, 2017 at 6:25 pm

Posted in History

Observations on column 3 of TM #4 sequence, and mystery remains

For the TM #4 , hypothetically, an infinite
sequence is generated a bit at a time.

By arranging this sequence into rows of
eight, some simplication occurs:
(a) The first column is all 3s
(b) The second column is all 1s.
(c) And so on.

Suppose we denote the sequence by
s(1), s(2), s(3), s(4), and so on.

Then, the first column consists of
s(1), s(9), s(17), s(25), …

We say that the index takes on the values
1, 9, 17, 25, …
for the first column.

For the 3rd column, the index “j” takes on
the values 3, 11, 19, etc.

It appears that s(j) <= j+2 for indices j
with j == 3 (modulo 8), in the 3rd column.

I’ve tested in part the supposition that
s(j) can be obtained from j+2 by deleting
some of the leading bits of j+2 expressed in
binary. The number of bits deleted n_j can be
0, 1, … but there must result s(j) >= 5.

When s(j) = j+2 [3rd colum case still],
then we say that j+2 is “an allowable number”.

Is s( s(j) – 2) = s(j) ?

Are the s(j) allowable numbers?
Perhaps, yes.

Is s(j) the largest allowable number
contained in j+2 as a bit-string,
starting from the right, i.e. the least
significant bit?

Perhaps yes…

How do we determine, given j,
whether s(j) = j+2? When is
a number allowable?

This looks quite hard.

Below, for each j in
{3, 11, 19, …}
we show j+2 in the left column, and
s(j) in the right column:
j+2 s(j)
==================
101 101
1101 1101
10101 10101
11101 11101
100101 100101
101101 101101
110101 110101
111101 111101
1000101 101
1001101 1001101
1010101 1010101
1011101 1011101
1100101 1100101
1101101 1101101
1110101 1110101
1111101 1111101
10000101 101
10001101 1101
10010101 10010101
10011101 11101
10100101 100101
10101101 10101101
10110101 10110101
10111101 10111101
11000101 101
11001101 11001101
11010101 11010101
11011101 11011101
11100101 11100101
11101101 11101101
11110101 11110101
11111101 11111101
100000101 101
100001101 1101
100010101 10101
100011101 11101
100100101 100101
100101101 101101
100110101 100110101
100111101 111101
101000101 101
101001101 1001101
101010101 101010101
101011101 1011101
101100101 1100101
101101101 101101101
101110101 101110101
101111101 101111101
110000101 101
110001101 1101
110010101 110010101
110011101 11101
110100101 100101
110101101 110101101
110110101 110110101
110111101 110111101
111000101 101
111001101 111001101
111010101 111010101
111011101 111011101
111100101 111100101
111101101 111101101
111110101 111110101
111111101 111111101
1000000101 101
1000001101 1101
1000010101 10101
1000011101 11101
1000100101 100101
1000101101 101101
1000110101 110101
1000111101 111101
1001000101 101
1001001101 1001101
1001010101 1010101
1001011101 1011101
1001100101 1100101
1001101101 1101101
1001110101 1001110101
1001111101 1111101
1010000101 101
1010001101 1101
1010010101 10010101
1010011101 11101
1010100101 100101
1010101101 10101101
1010110101 1010110101
1010111101 10111101
1011000101 101
1011001101 11001101
1011010101 1011010101
1011011101 11011101
1011100101 11100101
1011101101 1011101101
1011110101 1011110101
1011111101 1011111101
1100000101 101
1100001101 1101
1100010101 10101
1100011101 11101
1100100101 100101
1100101101 101101
1100110101 1100110101
1100111101 111101
1101000101 101
1101001101 1001101
1101010101 1101010101
1101011101 1011101
1101100101 1100101
1101101101 1101101101
1101110101 1101110101
1101111101 1101111101
1110000101 101
1110001101 1101
1110010101 1110010101
1110011101 11101
1110100101 100101
1110101101 1110101101
1110110101 1110110101
1110111101 1110111101
1111000101 101
1111001101 1111001101
1111010101 1111010101
1111011101 1111011101
1111100101 1111100101
1111101101 1111101101
1111110101 1111110101
1111111101 1111111101
10000000101 101
10000001101 1101
10000010101 10101
10000011101 11101
10000100101 100101
10000101101 101101
10000110101 110101
10000111101 111101
10001000101 101
10001001101 1001101
10001010101 1010101
10001011101 1011101
10001100101 1100101
10001101101 1101101
10001110101 1110101
10001111101 1111101
10010000101 101
10010001101 1101
10010010101 10010101
10010011101 11101
10010100101 100101
10010101101 10101101
10010110101 10010110101
10010111101 10111101
10011000101 101
10011001101 11001101
10011010101 10011010101
10011011101 11011101
10011100101 11100101
10011101101 10011101101
10011110101 11110101
10011111101 10011111101
10100000101 101
10100001101 1101
10100010101 10101
10100011101 11101
10100100101 100101
10100101101 101101
10100110101 100110101
10100111101 111101
10101000101 101
10101001101 1001101
10101010101 101010101
10101011101 1011101
10101100101 1100101
10101101101 101101101
10101110101 10101110101
10101111101 101111101
10110000101 101
10110001101 1101
10110010101 110010101
10110011101 11101
10110100101 100101
10110101101 110101101
10110110101 10110110101
10110111101 110111101
10111000101 101
10111001101 111001101
10111010101 10111010101
10111011101 111011101
10111100101 111100101
10111101101 10111101101
10111110101 10111110101
10111111101 10111111101
11000000101 101
11000001101 1101
11000010101 10101
11000011101 11101
11000100101 100101
11000101101 101101
11000110101 110101
11000111101 111101
11001000101 101
11001001101 1001101
11001010101 1010101
11001011101 1011101
11001100101 1100101
11001101101 1101101
11001110101 11001110101
11001111101 1111101
11010000101 101
11010001101 1101
11010010101 10010101
11010011101 11101
11010100101 100101
11010101101 10101101
11010110101 11010110101
11010111101 10111101
11011000101 101
11011001101 11001101
11011010101 11011010101
11011011101 11011101
11011100101 11100101
11011101101 11011101101
11011110101 11011110101
11011111101 11011111101
11100000101 101
11100001101 1101
11100010101 10101
11100011101 11101
11100100101 100101
11100101101 101101
11100110101 11100110101
11100111101 111101
11101000101 101
11101001101 1001101
11101010101 11101010101
11101011101 1011101
11101100101 1100101
11101101101 11101101101
11101110101 11101110101
11101111101 11101111101
11110000101 101
11110001101 1101
11110010101 11110010101
11110011101 11101
11110100101 100101
11110101101 11110101101
11110110101 11110110101
11110111101 11110111101
11111000101 101
11111001101 11111001101
11111010101 11111010101
11111011101 11111011101
11111100101 11111100101
11111101101 11111101101
11111110101 11111110101
11111111101 11111111101
100000000101 101
100000001101 1101
100000010101 10101
100000011101 11101
100000100101 100101
100000101101 101101
100000110101 110101
100000111101 111101
100001000101 101
100001001101 1001101
100001010101 1010101
100001011101 1011101
100001100101 1100101
100001101101 1101101
100001110101 1110101
100001111101 1111101
100010000101 101
100010001101 1101
100010010101 10010101
100010011101 11101
100010100101 100101
100010101101 10101101
100010110101 100010110101
100010111101 10111101
100011000101 101
100011001101 11001101
100011010101 11010101
100011011101 11011101
100011100101 11100101
100011101101 100011101101
100011110101 11110101
100011111101 11111101
100100000101 101
100100001101 1101
100100010101 10101
100100011101 11101
100100100101 100101
100100101101 101101
100100110101 100110101
100100111101 111101
100101000101 101
100101001101 1001101
100101010101 101010101
100101011101 1011101
100101100101 1100101
100101101101 101101101
100101110101 101110101
100101111101 101111101
100110000101 101
100110001101 1101
100110010101 110010101
100110011101 11101
100110100101 100101
100110101101 110101101
100110110101 100110110101
100110111101 110111101
100111000101 101
100111001101 111001101
100111010101 100111010101
100111011101 111011101
100111100101 111100101
100111101101 100111101101
100111110101 111110101
100111111101 100111111101
101000000101 101
101000001101 1101
101000010101 10101
101000011101 11101
101000100101 100101
101000101101 101101
101000110101 110101
101000111101 111101
101001000101 101
101001001101 1001101
101001010101 1010101
101001011101 1011101
101001100101 1100101
101001101101 1101101
101001110101 1001110101
101001111101 1111101
101010000101 101
101010001101 1101
101010010101 10010101
101010011101 11101
101010100101 100101
101010101101 10101101
101010110101 101010110101
101010111101 10111101
101011000101 101
101011001101 11001101
101011010101 101011010101
101011011101 11011101
101011100101 11100101
101011101101 101011101101

Written by meditationatae

September 16, 2017 at 8:17 pm

Posted in History

Allowable numbers: when is 8j + 5 allowable?

Below, the first 350 values of j for which 8j +5 is an allowable number:

 

0
1
2
3
4
5
6
7
9
10
11
12
13
14
15
18
21
22
23
25
26
27
28
29
30
31
38
42
45
46
47
50
53
54
55
57
58
59
60
61
62
63
78
86
90
93
94
95
102
106
109
110
111
114
117
118
119
121
122
123
124
125
126
127
150
154
157
159
174
182
186
189
190
191
206
214
218
221
222
223
230
234
237
238
239
242
245
246
247
249
250
251
252
253
254
255
278
285
310
314
317
319
342
346
349
351
366
374
378
381
382
383
406
410
413
415
430
438
442
445
446
447
462
470
474
477
478
479
486
490
493
494
495
498
501
502
503
505
506
507
508
509
510
511
541
566
573
602
607
622
638
662
669
694
698
701
703
726
730
733
735
750
758
762
765
766
767
790
797
822
826
829
831
854
858
861
863
878
886
890
893
894
895
918
922
925
927
942
950
954
957
958
959
974
982
986
989
990
991
998
1002
1005
1006
1007
1010
1013
1014
1015
1017
1018
1019
1020
1021
1022
1023
1053
1078
1114
1174
1210
1215
1238
1245
1270
1274
1277
1279
1309
1334
1341
1370
1375
1390
1406
1430
1437
1462
1466
1469
1471
1494
1498
1501
1503
1518
1526
1530
1533
1534
1535
1565
1590
1597
1626
1631
1646
1662
1686
1693
1718
1722
1725
1727
1750
1754
1757
1759
1774
1782
1786
1789
1790
1791
1814
1821
1846
1850
1853
1855
1878
1882
1885
1887
1902
1910
1914
1917
1918
1919
1942
1946
1949
1951
1966
1974
1978
1981
1982
1983
1998
2006
2010
2013
2014
2015
2022
2026
2029
2030
2031
2034
2037
2038
2039
2041
2042
2043
2044
2045
2046
2047
2102
2138
2234
2269
2294
2301
2365
2399
2414
2430
2461
2486
2493
2522
2527
2542
2558
2589
2614
2650
2710
2746
2751
2774
2781
2806
2810
2813
2815

Written by meditationatae

September 15, 2017 at 5:15 pm

Posted in History