Talk:Nerror

I actually have a draft of very similar language to this, also inspired by ErrorBucket:

0, 1 - enqueue to active
~ - swap queues if front is 0
* - dequeue

First queue starts with a single 1 and second with a single 0, so it is trivially TC and thus I didn't upload it. --ChuckEsoteric08 (talk) 06:15, 30 October 2026 (UTC)

Is this really "trivially" TC? It looks like it has slightly more chance of being TC than Nerror, but all the obvious ways of making a relatively direct translation to Cyclic Tag have issues. Main issue is the swapping is a non-destructive read, so the command is there when you swap back. Both this and Nerror seems to have the problem that if you use the 2nd queue as a 'junk' queue, you still need to deterministically get back to the active queue after every throwaway sequence of writes, but the junked data is going to randomise that. It needs to have a constant meaning on the junk queue, and a program specific meaning on the real-data queue. Unless there is a clever way to pair every instruction symbol, or make every production symmetrical about the queues? If that is trivial, it should be easy to describe. These languages look more similar to 3 command Cyclic Tag than ErrorBucket, and nothing about Error Bucket looks trivial. Its TCness is claimed in terms of a translation to Cyclic Tag, so I think I'm comparing these to the appropriate existing language. Salpynx (talk) 21:26, 31 October 2026 (UTC)

That one I described is trivially TC as it does not remove front bit from the queue when checking it, and as second queue always has 0 at the front it is possible to deterministically go back to the first Queue. And I afree with both of them being more similar to Cyclic Tag than to ErrorBucket. This one I describe wasn't the final version as I planned to change some things to make it more similar to ErrorBucket. --ChuckEsoteric08 (talk) 21:43, 31 October 2026 (UTC)

Oh ok, looks like ~*~ is equivalent to cyclic tag's ;. I had to create an interpreter, figure out the transform and run the cyclic tag Collatz program to confirm it works just to see that. This wiki is making me dumber / more sceptical when more and more vague TC claims are made. Some people seem to think loops are sufficient, other claims are even wilder and it's not remotely clear if they are worth investigating. I'd spent longer trying to make sense of Nerror and perhaps conflated the problems. Sorry for doubting your claim, but having something interesting stated clearly and verifiably on this wiki seems a rarity these days. Salpynx (talk) 23:20, 31 October 2026 (UTC)

Nerror Busy Beaver

For some reason I decided that running a Busy Beaver type of thing on this would be interesting. I counted "steps", i.e. each individual instruction, including the last \ that halts the program. Here are my results:

Length	Program	Steps
1	\	≥1
2	\0, \1, \\	≥1
3	0\\, 1\\	≥3
4	10\\	≥8
5	100\\	≥20
6	100\\1	≥17
7	111\\01	≥103
8	111\\10\	≥149
9	11\110\\\	≥701
10	100\\0\10\	≥255

I use ≥ because I technically haven't proven that all the programs that run longer never halt, but I'd expect them to be easy to rule out with simple deciders. At the very least, I ran all the programs for 9999 steps, which is much longer than any of the halting times here, so hopefully that was enough to catch all the halting programs. Here's the code I used:

import collections, itertools

class Nerror:
    def __init__(self, program):
        self.instructions = itertools.cycle(program)
        self.queues = (collections.deque(), collections.deque())
        self.active_queue = self.queues[1]
    def __iter__(self):
        return self
    def __next__(self):
        instruction = next(self.instructions)
        if instruction == "0":
            self.active_queue.append(False)
        elif instruction == "1":
            self.active_queue.append(True)
        elif len(self.active_queue) == 0:
            raise StopIteration
        else:
            self.active_queue = self.queues[self.active_queue.popleft()]
        return False

programs = {"".join(i): Nerror(i) for i in itertools.product("01\\", repeat=8)}
for steps in range(1, 10000):
    for code, runtime in programs.items():
        if runtime is None:
            continue
        if next(runtime, True):
            print(f"{code} halts in {steps} steps.")
            programs[code] = None

I haven't implemented any filtering of programs yet (e.g. without even running the program, you can guarantee that if it neither starts with a \ nor contains \\, it can never halt), so the search is definitely a bit inefficient, but it works well enough for the small cases. –PkmnQ (talk) 08:15, 30 October 2026 (UTC)

0\00010\\\0: 6675

11\01100\\0\: 9058

111\11\11\\01: 16846

0\0\00010\\\00: 4799

0\00\001\\00000: 398035

--Blashyrkh (talk) 12:44, 30 October 2026 (UTC)