WOLFRAM NOTEBOOK

In[]:=
Plot[{4^(.75n),2.8284271247461903`^n},{n,1,20}]
Out[]=
5
10
15
20
2e+7
4e+7
6e+7
8e+7
In[]:=
4^.75
Out[]=
2.82843
In[]:=
2^28
Out[]=
268435456
3
{28,{2,264107671}}
1/Sqrt[t]
In[]:=
Sqrt[643.*^9]
Out[]=
801873.
In[]:=
1/%
Out[]=
1.24708×
-6
10
In[]:=
1/Sqrt[2.5*^7]
Out[]=
0.0002
In[]:=
1/%
Out[]=
5000.

Send blocks of 100k

What we want back is mostly de novo nonterminating cases

Any strings that reach a critical size .... will get checkpointed

We will send people lists of already known checkpoints

What fraction of initial conditions reach 1000 elements?

How diverse are the results

TSDirectEvolveList
Out[]=
PostTagSystem`
In[]:=
ParallelEvaluate[Needs["PostTagSystem`"]]
In[]:=
PostTagSystemFinalState[{0,{1,1,1,0,1,1,1,0,1}},800]
Out[]=
{1,{1,0,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,0,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1}}
In[]:=
CountDistinct[#]/Length[#]&[DeleteMissing[ParallelTable[SelectFirst[TSPhaseEvolveList[{0,RandomInteger[1,30]},8000],Length[#[[2]]]>100&],1000]]]//N
Out[]=
0.678832
In[]:=
CountDistinct[#]/Length[#]&[DeleteMissing[ParallelTable[SelectFirst[TSPhaseEvolveList[{0,RandomInteger[1,30]},8000],Length[#[[2]]]>200&],10000]]]//N
Out[]=
0.55814
In[]:=
CountDistinct[#]/Length[#]&[DeleteMissing[ParallelTable[SelectFirst[TSPhaseEvolveList[{0,RandomInteger[1,30]},8000],Length[#[[2]]]>400&],10000]]]//N
Power
:Infinite expression
1
0
encountered.
Infinity
:Indeterminate expression 0ComplexInfinity encountered.
Out[]=
Indeterminate
In[]:=
{CountDistinct[#],Length[#]}&[DeleteMissing[ParallelTable[SelectFirst[TSPhaseEvolveList[{0,RandomInteger[1,30]},20000],Length[#[[2]]]>400&],100000]]]
Out[]=
{22,153}
In[]:=
22/153.
Out[]=
0.143791
In[]:=
{{100,.68},{200,.55},{400,.143}}
Out[]=
{{100,0.68},{200,0.55},{400,0.143}}
In[]:=
ListPlot[%155]
Out[]=
150
200
250
300
350
400
0.1
0.2
0.3
0.4
0.5
0.6
0.7
In[]:=
.55/Sqrt[2]
Out[]=
0.388909
In[]:=
.68/Sqrt[2]
Out[]=
0.480833
In[]:=
Length[#[[2,2]]]&/@With[{re=PostTagSystem[{0,{1,1,1,1,1,1,0,1,0}}]},Table[{i,re["State",i]},{i,1,25000,1}]]
Out[]=
{9,10,10,10,11,11,11,11,11,11,11,12,11,12,12,12,12,12,12,12,12,12,13,13,13,14,13,14,13,14,13,14,13,14,14,14,14,14,15,15,15,16,16,16,17,17,17,18,17,18,17,18,18,18,18,18,19,19,19,19,19,20,19,20,20,20,21,21,21,22,21,22,21,22,22,22,22,22,21,22,22,22,23,23,23,23,23,24,23,24,24,24,25,25,25,26,25,26,25,25,25,26,25,26,26,26,26,26,25,26,26,26,27,27,27,27,
⋯24768⋯
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
large output
show less
show more
show all
set size limit...
In[]:=
Union[%]
Out[]=
{0,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216}
In[]:=
Differences[%]
Out[]=
{9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}

When we get back a result package...

Combine with other result packages

Prep these for subsequent sent packages

Send to other people for full running.......

They can send back their results after a trillion steps.... or if it gets bigger than some size....

We need to parametrize the comparison checkpoint

Parameters

For trawlers [generalists] [broad explorers] [ breadth-first searchers ] [ primary inspection ]

Question: will they be able to run in parallel on a single machine? [can Max’s code work like this?]
We give them their block of initial conditions
{length,startnumber,endnumber}
We also give them:
• checksize : at what size to do the comparison with the known string [ it will always hit a given size ]
• the list of known sequences
◼
  • the maximum time to run a single string for for (in case they have a string that doesn’t grow)
    • They return:
    ◼
  • for each init:
    • {basic disposition, data}
    Dispositions:
    - Found to terminate (i.e. goes to {}) [we know number of steps] <”terminated”>
    - Found to repeat [we know number of doublings in step count for transient; period; final state] <”repeated”>
    - Found to match checkpoint string [we know number of steps to match, and what the match was] <”checkpointed”> [gets sent to long-haulers]
    - <<<< Exceeded max size [ we know how many steps, and what the final state was ] [ manual inspection ] impossible >>>>>
    - Ran to the max step count [we know the final state <or just give the size of the final state> ] ⟶ manual inspection

    For long-haul [specialists] [deep explorers] [ secondary inspection ]

    We give them:
    a bucket of initial conditions
    ​
    Let them run as long as possible
    They return for each one:
    They will give us dispositions:
    - terminated (number of steps + max intermediate size)
    - repeated (number of doublings + number of steps + final state + max intermediate size)
    - too big [i.e. memory limit] (number of steps to hit limit)
    - ran out of time (number of steps, final state [< 10 MB?] , max intermediate size)
    I.e. 20 trillion steps

    For long-haul relay runners

    Specific Programs

    wolfram-postproject

    -trawl

    -cribfile XXXX
    -criblength / maxlength
    -initlength 30
    -initrange XXXXXX XXXXXXX
    -maxsteps [ 10^10 ? ]
    -timeconstraint XXXXX
    -outputfile XXXXX

    -longhaul

    -initfile XXXX [things to search]
    [ should allow long initial strings ]
    -timeconstraint XXXXX
    -sizeconstraint XXXXX [~ 10^9 ]
    -outputfile XXXXX

    Return values

    Serialize a C struct??

    Head End

    Decide on crib sizes

    Register outputs from trawlers

    We need to be able to prime the system with a crib file...
    then ingest crib results from trawlers

    We would harvest crib results, and generate a de-duped list

    Maximum list size ~10,000
    If the number of cribs is larger, need to increase the crib size....
    Wolfram Cloud

    You are using a browser not supported by the Wolfram Cloud

    Supported browsers include recent versions of Chrome, Edge, Firefox and Safari.


    I understand and wish to continue anyway »

    You are using a browser not supported by the Wolfram Cloud. Supported browsers include recent versions of Chrome, Edge, Firefox and Safari.