bbchallenge - #bb6

``` 1RB0RE_0RC---_1LD1LE_1LE1LD_1RF0LC_1RA1RF (chaotic 1dCA in bell) (...0 a1 a2 ... an > b1 b2 ... bm 0...) := (0^inf 0 1^a1 0 1^a2 ... 0 1^an E> 1^b1 0 1^b2 0 ... 1^bm 0 0^inf) (...0 a1 a2 ... an < b1 b2 ... bm 0...) := (0^inf 0 1^a1 0 1^a2 ... 0 1^an <E 1^b1 0 1^b2 0 ... 1^bm 0 0^inf) start from: ...0 1 < 2 0... local rewrite rules: a > 0 b c+1 ----------- (R) a+b+2 0 > c a > b+2 --------- (RL) a+1 < b+1 a > 1 0... ---------- (RL'') a+1 < 0... a 2b+1 < --------- (L) < a+2 1^b 2a < ------- (LR) > 0 1^a a > 0 b 0... -------------- (RL') a+b+3 < 2 0... ```

``` halting cryptid candidate: 1RB1RA_0RC1RC_1LD0LF_0LE1LE_1RA1LD_---0LC start from N(4,4) N(2n,m+2) --> N(3n+3,m) N(2n+1,m+1) --> N(3n+4,m) N(2n+4,0) --> halt N(2n+4,1) --> N(4,6n+20) N(2n+5,0) --> N(4,6n+22) example: (4,4),(9,2),(16,1),(4,56),(9,54),(16,53),(27,51),(43,50),(67,49),(103,48),(157,47),(238,46),(360,44),... ```

uni's program outputs `Panic("InternerExp oom")` on these TMs. most of them look like cryptids, both antihydra and the (halting cryptid) candidate above are in this list. the second TM in the list looks like antihydra variant.

the first unlabeled TM on the list is another probviously halting tetrational cryptid``` 1RB1RE_1LC1LD_---1LA_1LB1LE_0RF0RA_1LD1RF A(m, n+9) = 0^inf 1^m (01)^n 0 A> 0^inf rules: A(m+4, 2n) -> A(m, 3n) A(m+4, 2n+1) -> A(m, 3n+1) A(0, 2n) -> halt A(0, 2n+1) -> A(6n-23, 10) A(1, 2n) -> A(6n-23, 10) A(1, 2n+1) -> halt A(2, n) -> halt A(3, 2n) -> A(6n-20, 10) A(3, 2n+1) -> A(6n-18, 10) start from A(1, 10) B(m) = A(m, 10) B(4m) -> B(3 * HydraMap^m(10) - 26) if HydraMap^m(10) is odd B(4m+1) -> B(3 * HydraMap^m(10) - 23) if HydraMap^m(10) is even B(4m-1) -> B(2 * HydraMap^m(10) - 20) in all other cases, halt start from B(1) iterating HydraMap on 10: 10, 15, 22, 33, 49, 73, 109, 163, 244, 366, 549, 823, 1234, ... B(1) -> B(3*10-23) = B(7) -> B(2*22-20) = B(24) -> B(3*109-26) = B(301) -> B(3*153090419621086-23) = B(459271258863235) -> B(2*HydraMap^114817814715809(10)-20)```

oh my goodness the second unlabeled machine on that list looks theoretically capable of f\_ω growth rate *and* it uses the hydra map

the third unlabeled one on the list is a pretty simple non-halting TM``` 1RB0LE_1LC1RA_---1LD_0RB1LF_1RD1LA_0LA0RD A(n) = 0^inf <A 0 1^n rules: A(6n) -> A(12n+3) A(6n+1) -> A(12n+6) A(6n+2) -> halt A(6n+3) -> A(9n+9) A(6n+4) -> halt A(6n+5) -> A(9n+12) start from A(3) as we can see, everything that doesn't halt goes to A(6m) or A(6m+3) for some m, so halting is unreachable```

My analysis of `1RB1RA_0RC1RC_1LD0LF_0LE1LE_1RA0LB_---0LC`: ``` 1RB1RA_0RC1RC_1LD0LF_0LE1LE_1RA0LB_---0LC C(a, b, c) = $ 1^2a+1 C> 0^2b 1^c 01 $ Level 1: C(a, b+2, c) -> C(a+3, b, c) C(a, 1, c+2) -> C(1, a+3, c) C(a, 0, c+1) -> C(1, a+1, c) C(a, 0, 0) -> C(1, 2, 2a+3) C(a, 1, 1) -> C(1, 2, 2a+7) C(a, 1, 0) -> Halt(2a+5) Level 2: C(1, 2b, c+1) -> C(1, 3b+2, c) C(1, 2b+1, c+2) -> C(1, 3b+4, c) C(1, 2b, 0) -> C(1, 2, 6b+5) C(1, 2b+1, 1) -> C(1, 2, 6b+9) C(1, 2b+1, 0) -> Halt(6b+7) C(1, 0, 0) @11 C(1, 2, 5) @55 ... C(1, 17, 1) C(1, 2, 57) ... C(1, 70_091_065, 1) C(1, 2, 210_273_201) ... ``` This feels just like the Mother of Giants! And it will be hard to simulate to the next reset config. For my code I'm seeing O(n^2) runtime and we've made almost no progress: ``` 0 C(1, 2, 5) [0s] 4 C(1, 2, 57) [0s] 45 C(1, 2, 210_273_201) [0s] 100_000 C(1, 10^17_602, 210_123_530) [1s] 200_000 C(1, 10^35_211, 209_973_408) [4s] 300_000 C(1, 10^52_820, 209_823_652) [10s] 400_000 C(1, 10^70_429, 209_673_652) [17s] 500_000 C(1, 10^88_039, 209_523_616) [27s] 600_000 C(1, 10^105_648, 209_373_548) [38s] 700_000 C(1, 10^123_257, 209_223_420) [52s] 800_000 C(1, 10^140_866, 209_073_477) [68s] 900_000 C(1, 10^158_475, 208_923_310) [86s] 1_000_000 C(1, 10^176_084, 208_773_236) [107s] ```

first one labeled `"halting cryptid candidate"-like?` on the list``` 1RB0RE_1LC1LD_0RA0LD_1LB0LA_1RF1RA_---1LB A(n,m) = 0^inf (01)^(3n-4) A> (01)^m 0^inf A(2n,m) -> A(3n,m-2) A(2n+1,m) -> A(3n+1,m-1) A(n,0) -> A(2,3n-4) A(n,-1) -> halt start from A(2,0) it's kinda like the original halting cryptid candidate - we can rewrite it like this: a_0 = 2 and a_(i+1) = HydraMap(a_i) b_0 = 0 and b_(i+1) = b_i+(1 if a_i is odd otherwise 2) c_0 = 0 and c_(i+1) = 3a_j-4 where j is such that b_j = c_i a: 2, 3, 4, 6, 9, 13, 19, 28, 42, 63, 94, 141, ... b: 0, 2, 3, 5, 7, 8, 9, 10, 12, 14, 15, 17, ... c: 0, 2, 5, 14, 185, 22205951667644132025548, ...```

``` 1RB0LC_0LC0RF_1RD1LC_0RA1LE_---0LD_1LF1LA A(n,m) = 0^inf 1^n 0 F> (01)^m 0^inf A(2n,m) -> A(3n+6,m-3) A(2n+1,m) -> A(3n+4,m-1) A(2n,2) -> A(3n+5,0) A(2n+1,0) -> A(3n+3,0) A(4n,0) -> halt A(4n+2,0) -> A(1,3n+2) A(4n,1) -> A(1,3n+1) A(4n+2,1) -> halt start from A(1,0) (1,0) -> (3,0) -> (6,0) -> (1,5) -> (4,4) -> (12,1) -> (1,10) -> (4,9) -> (12,6) -> (24,3) -> (42,0) -> (1,32) -> ... -> (42,22) -> (69,19) -> (106,18) -> (165,15) -> (250,14) -> (381,11) -> (574,10) -> (867,7) -> (1303,6) -> (1957,5) -> (2938,4) -> (4413,1) -> (6622,0) -> (1,4967) -> ... -> (1,14368104968158922075826107897180157472284778921629891726072102154787953803159846292172983561900377711849897006427931013549455392544971918174039397292047183836725754592289319138760681981985121998538399879663080278192689282242683391905756667361944058503279816320482221006589444678672938373180284730537542284274407184691680540140302771101361561704028370606196721983814161423625115635349884218310358225536631663390134886195173210534077626946216488582) and then we need about 2^1481.1028 iterations of this not-quite-hydra map to see the next jump```

third one with that label``` 1RB1LE_0LC0LB_1RD1LC_1RD1RA_1RF0LA_---1RE A(n+6,m) = 0^inf <C (10)^n 1^m 0^inf A(2n,m) -> A(3n,m-3) A(2n+1,m) -> A(3n+1,m-2) A(2n,0) -> translated cycler A(2n+1,0) -> A(6,6n-15) A(n,1) = A(n+1,0) A(2n,2) -> halt A(2n+1,2) -> A(6,6n-10) start from A(6,3) (6,3) -> (9,0) -> (6,9) -> (9,6) -> (13,4) -> (19,2) -> (6,44) -> ... -> (19,37) -> ... -> (5395,2) -> (6,16172) -> ... -> (6,11499706784674840553982963244335134925926292012180535894331458059790938778878968481621445560196932470184062569880553764866025123766354799684631203637298859743405413224499198074720853448543344037846492928533557309269754344024578940398650604022127671219212868204078482696840863421497983802250964886170004962960289410195027865266357767132492619285668547610786689057240759204449610723369114500644414980504801780095838843221096818761115062075635136327221478807478315079387140446926256956991460845996815269568899367429919830588305329333143088760745263315773849396110871808200715753985864340607449243323203432825658435566757684843141746344665372901933843352127530984700134774127941919667681053930904263388909263935331661538599899139106183915539213591614541216854566127559305092174287252340495305601083110420028359390503735043199218514769778963279448332394384065634487789305567164753945749722964276916798856029480119093613769743710050061532020376588252691451260866180293121510320047092727822141164473867037149648467306335820387292808041642440275447680218167244359914165331523654149803989876115624995378063107743975850563832540321335181838796733470)```

last one labeled `"halting cryptid candidate"-like?` has 2/3 chance of translated cycling and 1/3 chance of halting``` 1RB0RC_0LC0LB_0LD1LC_0LE1LA_0LF---_1RF1RA A(n,m) = 0^inf <F 0^n 1^m 0^inf A(4n,m) -> A(9n+11,m-3) A(4n+1,m) -> A(9n+15,m-3) A(4n+2,m) -> A(9n+12,m-2) A(4n+3,m) -> A(9n+16,m-2) A(n,0) -> translated cycler A(n,1) -> A(3,n+3) A(n,2) -> halt start from A(3,1) (3,1) -> (3,6) -> (16,4) -> (47,1) -> (3,50) -> (16,48) -> (47,45) -> (115,43) -> ... -> (119114448,1) -> (3,119114451)``` someone could run this for around 50 million steps to see if it halts/TCs on the next jump

``` 1RB0RB_1LC1RE_1LF0LD_1RA1LD_1RC1RB_---1LC start: P(2) P(2a) -> P(3a+4) P(2a+1) -> Q(a+2,1) Q(2a+3,b) -> P(b+5a+6) Q(2a+2,b) -> Q(a,b+2a+5) Q(1,2b+1) -> P(3b+8) Q(1,2b) -> Q(b+2,1) Q(0,b) -> halt P(a) := 0^inf 1^a 011 <D 0^inf Q(a,b) := 0^inf 1^(2a+1) <D 0 1^b 0^inf ```

``` 1RB1LA_1RC0RC_1LA1RD_1LE1RD_---1LF_1LE0LA start: (0,3,0) (a,3b, c) -> (0,a+3b+c+2,0) (a,3b+1,c) -> (a+b+2,c+2b,0) (a,3b+2,c) -> (0,a+b-1,c+2b+4), if a+b>0 (a,3b+2,c) -> halt, if a+b=0 (a,b,c) := 0^inf 1^a 0 1^b <A 0 1^(c+2) 0^inf ```

it halts after applying 933,995,238,981 rules!

about 10^36

an example of "cubic cap": ``` 1RB0RD_0LC1RA_0RA1LB_1RE1LB_1LF1LB_---1LE (a,b,c) := 0^inf 1^a <B 1 01^b 1^c 0^inf (a,b,c) -> (a-min(a,c),b+min(a,c),c-min(a,c)) (0,b,0) -> (2b,0,4) (0,b,1) -> (2b,0,4) (0,b,c+2) -> (2b+1,1,c) (1,b,0) -> halt (a+2,b,0) -> (a,0,2b+4) start: (0,0,0) ```

it LOOPS because of the attractor `(n,2n) -> (2n+2,n-1) -> (n+1,2n+2)`

`1RB---_0RC0RE_1RD1RF_1LE0LB_1RC0LD_1RC1RA` is a probviously halting cryptid. just an exponential one, specifically at each step it simply multiplies the main number by 8/3 and then changes a few things depending on what it was mod 3. the left side can change in a few ways to store information between these steps. if you start from the empty left side, there are some sequences of numbers you can get mod 3 which make the TM halt, and if the main number mod 3 was random, then the probability of this eventually happening would be 1 regardless of how long those sequences are. this is all standard stuff. however i'm pretty sure the shortest such sequence has length around 100. i think it's a fun puzzle to try to find one yourself. the shortest one i found on my own has length 110, though it's actually a group of 2^13\*3^15 = 117546246144 such sequences because some parts can be permuted with certain restrictions. specifically, each (n,m) in the following sequence of pairs can be replaced with any sequence of n 2's and m 0's whose first k elements contain at least k/3 2's for every k<=n+m: ||(1,0), (2,1), (1,0), (2,3), (1,0), (2,4), (1,0), (2,3), (1,0), (3,5), (1,0), (3,4), (1,0), (3,3), (1,0), (2,4), (1,0), (2,3), (1,0), (3,4), (1,0), (3,6), (1,0), (2,3), (1,0), (3,4), (1,0), (3,6), (1,0)|| (spoilered because i think it's a relatively fun puzzle to try to figure out on your own) for any given point at which the left side is empty, the probability that it will follow one of these sequences from that point is just above 1/3^87 i also ran a search on all sequences of only 0's and 2's (1's seem to always reset most of the progress you made in getting to a halting config so i ignored those) up to that length, and the shortest it found was length 107, so the only way it's less than that would be if either my code is wrong or somehow 1's manage to be useful for something other than resetting. so i think it's pretty reasonable to guess that from a given position with empty left side, the probability that the TM will halt before resetting the left side is around 1/3^80. the rest of the computation is the same as always: the expected number of times we generate a new random number mod 3 should be around 3^80, and since that happens only when the main number is roughly multiplied by 8/3, the number of 1s when halting should be around (8/3)^3^80 ≈ 10^10^37.8, and the halting time should be around (that)^2, i.e. around 10^10^38.1 i know, not that impressive compared to the current champion, but i'm posting it because i like the mechanism. also i guess it would still be in 11th place if this approximation is correct, though the current 11th place TM takes around 10^10^35.3 steps to halt so it's kinda close.

`1RB0LC_1LC0RD_1LF1LA_1LB1RE_1RB1LE_---0LE` is a tetrational probviously halting cryptid. the lower bound for when it halts is around 10^10^120395, and with each exponentiation it has a 1/4 chance of halting, so i think the expected halting time is around 10^10^10^10^10^120395 sadly we won't be able to run it any further, it uses the hydra map which we don't have a way to accelerate

and thank goodness i noticed that because this is a new 2nd place TM in BB(6)``` a_1 = (2^179+1)/3+179 a_2 = (2^a_1+1)/3+a_1 a_3 = (2^a_2+1)/3+a_2 a_4 = (2^a_3+1)/3+a_3-1 a_5 = (2^a_4+1)/3+a_4 the counters after overflow: (10)^17 11 (10)^5 11 (10)^3 11 (10)^2 1111 (10)^513 11 (10)^17 11 (10)^5 11 (10)^3 11 10 1111 (10)^(2^179+1) 11 (10)^513 11 (10)^17 11 (10)^5 11 (10)^4 1111 (10)^(2^a_1+1) 11 (10)^(2^179+1) 11 (10)^513 11 (10)^17 11 (10)^5 11 (10)^3 1111 (10)^(2^a_2+1) 11 (10)^(2^a_1+1) 11 (10)^(2^179+1) 11 (10)^513 11 (10)^17 11 (10)^5 11 (10)^3 11 (10)^(2^a_3+1) 11 (10)^(2^a_2+1) 11 (10)^(2^a_1+1) 11 (10)^(2^179+1) 11 (10)^513 11 (10)^17 11 (10)^5 11 (10)^2 11 (10)^(2^a_4+1) 11 (10)^(2^a_3+1) 11 (10)^(2^a_2+1) 11 (10)^(2^a_1+1) 11 (10)^(2^179+1) 11 (10)^513 11 (10)^17 11 (10)^4 111111 10 11 halt at roughly 2^a_5 ≈ 2^2^2^2^2^(2^179/3) ≈ 10^10^10^10^10^10^52.8```

``` 1RB1LA_1LC0RE_1LF1LD_0RB0LA_1RC1RE_---0LD start: (3,1) (0,2+c) --> (4+c,1) (1,c) --> halt (2+2b,c) --> (7+5b+c,1) (3+2b,c) --> (b,4+b+c) (b,c) := 0^inf <A 1^b 00 1^c 0^inf ```

i took a look at the 6-state machine on the shift-overflow counter wiki page, which apparently isn't solved yet: https://fiery.pages.dev/turing/explore/1RB0RF_1LC1RB_0RD0LB_---0LE_1RE0RA_1RD1RE it halts with roughly 2^(2^96/3)/3 1s on the tape and after roughly 2^(2^97/3) steps. it follows these rules:``` A(n,m) := 111 E> 1^(3n) 0 1^m A(n,6m+1) -> A(n+2m+1,2^(n+2m)+2^((2^(2m)-1)/3)+1) A(n,3m+2) -> halt with n+m+6 1s start from A(4,13) A(4,13) -> A(9,289) -> A(106,2^105+2^((2^96-1)/3)+1)``` since both 105 and (2^96-1)/3 are odd, that is A(106,3m+2), which halts as soon as the machine gets to the right side of the tape

here are the details of the A(n,6m+1) case:``` A(n,6m+1) = 111 E> 1^(3n) 0 1^(6m+1) --(translated cycles)--> 111 (001)^n 1 (001)^(2m) 0 A> 0 --(counting with 2m bits)--> 111 (001)^n 1 (111)^(2m) 0 A> 0 1^(2^(2m)-1) --(translated cycles)--> 111 (001)^(n-1) 111 (001)^(2m) 0 111 (001)^((2^(2m)-1)/3) 0 A> 0 --(counting with (2^(2m)-1)/3 bits)--> 111 (001)^(n-1) 111 (001)^(2m) 0 (111)^((2^(2m)+2)/3) 0 A> 0 1^(2^((2^(2m)-1)/3)-1) --(translated cycles)--> 111 (001)^(n-1) 111 (001)^(2m-2) 111 001 0 A> 0 1^(2^(2m)+2^((2^(2m)-1)/3)+3) --(counting with n+2m bits)--> 111^(n+2m+1) 0 A> 0 1^(2^(n+2m)+2^((2^(2m)-1)/3)) --(translated cycles)--> A(n+2m+1,2^(n+2m)+2^((2^(2m)-1)/3)+1)```

recursive record-breaking analysis for 2 layers of induction decided 167 holdouts

i wanna call this a probviously halting cryptid https://fiery.pages.dev/turing/explore/1RB1LD_1RC0LE_1LA1RE_0LF1LA_1RB0RB_---0LB if it halts, it seems to do so after at least around 1.24^1.24^530 steps (around 10^(3\*10^48)). it's a shift-overflow counter but the counting is chaotic, like in the two chaotic counter 3x3 holdouts. here's my python code for figuring out the sequence of states hitting a given bit, in case anyone wants to see if they can do something with it (0 is E, 1 is A and 2 is D):``` a = [0] ats = [1] atlen = 1 for _ in range(77): b = [] bts = [] btlen = 0 t = 0 bit = 0 starting = 1 while starting or bit: starting = 0 for i in range(len(a)): s = a[i] t += ats[i] btlen += ats[i] if s == 0: bit = 1 - bit b.append(bit) bts.append(t) t = 0 elif s == 1 and bit: b.append(2) bts.append(t) t = 0 elif s == 2: b.append(bit) bts.append(t) t = 0 t += atlen - ats[-1] a = b ats = bts```

oh and then there's this absolute beauty: `1RB0LD_0RC0RA_1LC0LA_---1LE_0LF0RE_0RA0LE` quickly reaches an "exponentiation"-like phase, where each multiplication consists of multiplying by **5/6** and then multiplying by **9/5** for a total of 9/6 = 3/2 (and adding a bunch of constants, which are determined possibly by the initial value mod 12 and also by the details of what is on the right side) that phase continues past step 14 billion, and during that time, the right side has been reduced from [first picture] to [second picture]

``` 1RB0LD_1RC1RA_1LD0RB_1LE1LA_1RF0RC_---1RE (a,2+b,c) --> (a,b,3+c) (a+1,0,c) --> (a,c,2) (a+1,1,c) --> (a,c,6) (0,0,c) --> halt (0,1,c) --> (2c+9,0,0) start: (3,0,0) (3,0,0) --> ... (25,0,0) --> ... (227097,0,0) --> ... (_,0,0) --> ... (a,b,c) := 0^inf 1^a 0 01^b 0 11^c+1 B> 0^inf ``` confirmed that it doesn't halt early

``` 1RB0LD_0RC0RF_0RD0RA_1LE0RD_1LF---_0LA1LA (n+a,b,2n+c) --> (a,n+b,c) (0,b,c) --> (5+3b,0,c) (1,10+b,0) --> halt (1,10+b,1) --> halt (2,b,0) --> (2,0,8+3b) (2,b,1) --> (2,0,11+3b) (3+a,b,0) --> (a,0,6+3b) (3+a,b,1) --> (a,0,9+3b) start: (10,0,12) ``` this machine is weird it does't halt in 8.9e12 rules (the first rule doesn't count) for small (a,0,c), none of them halts between 1e5 and 1e8 rules (use the simplified model that (1,b,0) and (1,b,1) halts) for each visited (a,0,c), log(c/a) seems to have a good distribution, which means that it doesn't fall into a fixpoint quickly and the (2,b,0),(2,b,1) rules are used for several times: ``` T=462: 2 673 1 T=41231: 2 59502 0 T=6056795: 2 8748186 1 T=45863796: 2 66242895 0 T=2012212661: 2 2906495658 1 T=10335020887: 2 14928329409 1 T=468871071868: 2 677258129269 1 ```

new code with B simplified

huh, `1RB1LC_1LC1RD_1LA0LB_0RB1RE_1RF0RA_---0RC` seems to just be probviously halting with exponential expected halting time, unless there's some parity argument for why it can't halt

``` A(a,b) := 0^inf 1^a 0 C> 1^b 0^inf A(a,b) -> A(2a+4,b-a-1) if a is even and b>=a+3 A(a,b) -> A(2a+3,b-a) if a is odd and b>=a+4 A(a,a+3) -> A(2a+1,9) if a is odd A(a,a+2) -> A(1,2a+7) A(a,a+1) -> A(4,2a+4) A(a,b) -> A(a-b+1,2b+3) if a>=b>=4 A(a,3) -> halt if a>=2 A(a,2) -> A(a-3,7) if a>=4 start: A(2,9)```

``` 1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB--- start: S(18) S(n) --> S((n+(3^i*6+i+4))/2), n mod 2 = i mod 2, 3^i*2-i-2 <= n <= 3^i*6-i-6 S(n) --> S(3^i*12-1), n mod 2 = (i+1) mod 2, 3^i*2-i <= n <= 3^i*6-i-10 ``` the rules are closed if `(3^i*2+i+5)/(2^v2(3^i*2+i+5))>=2i+14` for all `i>=50` is this easy to prove?

`1RB0LD_0RC0RE_1LC0LA_---1LE_0LF0RE_0RA0LE` proven non-halting

I ran the space-needle-esque model of `1RB1LA_0LC0RC_1LE1RD_1RE1RC_1LF0LA_---1LE` out to 10M iterations. Unsurprisingly, it didn't halt or hit 3 * 2^k for some k. Plot is log-log of f^n(5)

Looks like another ~~cryptid~~ chaotic TM: ``` 1RB---_0RC0RD_1LD1RB_0LE0LC_1RA0LF_1LD1LE Let A(a,b,c) = 0^inf 1^a 10^b C> 1^c 0^inf A(a+1,b,c+3) --> A(a,b+2,c) A(a,b,0) --> A(2b+1,1,a+1) A(a,b,1) --> A(2b+3,1,a+1) A(a,b,2) --> A(2b+5,1,a+1) A(0,b,c+5) --> A(2b+4,2,c) A(0,b,4) --> Halt A(0,b,3) --> Halt Start: A(0,1,0) ``` Simulated out to 1B "resets" (rule count ignoring the first rule): ``` 1_000_000_000 A(1_449_166_375, 1, 3_050_820_388) ``` Looks kind of like BMO1 where it only halts if a and c are "close" in some sense. Configs like `A(k,b,3k+{3,4})`