meditationatae

Just another WordPress.com site

More on b-numbers, part B

This is a continuation of the previous post on b-numbers.

===

For a b-number ‘x’ in the range 4096 to 8191 (13 bit length),
it appears at first glance that, modulo 4096,

x == y (mod 4096), where y is a b-number in
the range 1-4095;

Details:

 

k up to 4095:

 

5 // term 1
13
21
29
37
45
53
61
77
85 // term 10
93
101
109
117
125
149
173
181
189
205
213
221
229
237 x
245
253
309
341
365
373
381
405
429
437 x
445
461
469
477
485
493 x
501
509
629
693
725
749
757
765
821
853 // term 50
877
885
893
917
941
949
957
973
981
989
997
1005
1013
1021
1205
1237
1261
1277
1397
1461
1493
1517
1525
1533
1653
1717
1749
1773
1781
1789
1845
1877
1901
1909
1917
1941
1965
1973
1981
1997
2005
2013
2021
2029
2037
2045
2229
2285
2485 /
2517 // term 100
2541
2557
2741
2773
2797
2813
2933
2997
3029
3053
3061
3069
3253
3285
3309
3325
3445
3509
3541
3565
3573
3581
3701
3765
3797
3821
3829
3837
3893
3925 // t. 130
3949
3957
3965
3989
4013
4021
4029
4045
4053
4061 // term 140
4069
4077
4085
4093 // term 144

 

k from 4096 to 8191, modulo 4096

 

237 // b-number term number 145, modulo 4096
437
493
725
765
885
1013
1205
1261
1461
1493
1517
1533
1717
1749
1773
1789
1909
1973
2005
2029
2037
2045
2229
2285
2485
2517
2541
2557
2741
2773
2797
2813
2933
2997
3029
3053
3061
3069
3253
3285
3309
3325
3445
3509
3541
3565
3573
3581
3701
3765
3797
3821
3829
3837
3893
3925
3949
3957
3965
3989
4013
4021
4029
4045
4053
4061
4069
4077
4085
4093

 

Advertisements

Written by meditationatae

September 25, 2017 at 12:06 am

Posted in History

The b-numbers again

If we write the (hypothetical, from now on understood) sequence from TM #4 (chaotic), 5-state, 2-symbol tape of Marxen and Buntrock in rows of 8, the 3rd column has a complex structure.

Suppose we use “index 1”-notation, which just means that the first term of the sequence, 3, is written s(1) instead of s(0) as would be the case with arrays in C, C++, and so on.

Then the third column is made up of s(3) = 5, s(11), s(19), and in general s(8j + 3) for some integer j with 0<= j < oo.

Empirically,  s(j) <= j+2. When j is congruent to 3 modulo 8, so that s(j) is a third-column term, it happens that:

s(j) = j+2 exactly.

When this happens, in column 3, I call j+2 a b-number (basic number). Or in other words, if k is such that s(k-2) = k, and

k == 5 (mod 3), and of course k >2, then by definition k is a basic number or b-number.

When k == 5 (mod 3), but s(k-2) is not k, then I’ve called k a forbidden number. This is justified by studying the binary expansion of s(k-2)  when k is a forbidden number.

Empirical study gives some credence to the belief that, when k is not a b-number, s(k-2) can be obtained from ‘k’ by omitting one or more of the most significant bits of k, all consecutive bits, while always leaving perhaps 3 bits of ‘k’ to yield 101_(Base 2) = 5_(Base 10).

Moreover, a first look gave me a clue that when k is forbidden, then s(k-2) can be obtained from the binary expansion of k by omitting the most significant ‘1’ bit from k in base 2, and going on striking-out mentally the most significant ‘1’ bits (starting at the leftmost bit) and stopping when and only when the modified number is a b-number. Thus, if k is forbidden, s(k-2) would still be a b-number or basic number.

The new feature I hadn’t looked at previously is the count of b-numbers by bit-length.

The following table has this , with a coming explanation:

n count(n)
======================
10 22
11 32
12 48
13 71
14 106
15 158
16 234
17 348
18 518
19 772
20 1152

n is a bit-length of a positive integer.
Examples: 6 has bit-length 3, 2^k has
bit length k+1, 100 has bit-length 7,
ans 2^k – 1 has bit-length k.

count(n) is the number of b-numbers with bit-length equal to n.
So there are 22 b-numbers with 10 bits, which means in the
range 512 to 1023 inclusive. And so on up to 20 bits.

You’ll see that c(n+1) is approximately (3/2)*c(n),
better than chance in my opinion.

In other words, while there are 48 b-numbers
in the range 2048 to 4095, there are only
23 in the range 4096 to 8191 (which is
twice as long).
To if we increase n by +1, the frequency of
b-numbers is reduced by a factor of 4 approximately.

Perhaps these correspond to two extra “pseudo-random”
boolean 0/1 conditions for a 13-bit b-number, as
compared to a 12-bit b-number. This line of
inquiry has not so far been pursued further.

If you look at the first few dozen b-numbers,
you might notice that 2^k – 3 is a b-number
for k = 3, 4, 5, 6, 7, … 15, …
There are other “magic numbers” like 3.
While consistent, these “magic numbers”
and their patterns still give complicated
sequences.

Perhaps I missed something that could be guessed
from the fact that c(n+1) is approximately (3/2)*c(n).

I find this problem of pattern recognition both
tantalizing and frustrating, because it is
produced by such a seemingly simple 5-state,
2-symbol Turing machine, starting with a
blank tape.

The first 100 b-numbers :

5
13
21
29
37
45
53
61
77
85
93
101
109
117
125
149
173
181
189
205
213
221
229
237
245
253
309
341
365
373
381
405
429
437
445
461
469
477
485
493
501
509
629
693
725
749
757
765
821
853
877
885
893
917
941
949
957
973
981
989
997
1005
1013
1021
1205
1237
1261
1277
1397
1461
1493
1517
1525
1533
1653
1717
1749
1773
1781
1789
1845
1877
1901
1909
1917
1941
1965
1973
1981
1997
2005
2013
2021
2029
2037
2045
2229
2285
2485
2517

 

 

Written by meditationatae

September 23, 2017 at 7:01 am

Posted in History

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()

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