User:Rainwave/Drafts/Angel v. Devil

Angel v. Devil is an esoteric programming language created by User:Rainwave in 2026. It is inspired by Conway's Angel problem.

Semantics

The language operates on a bidirectionally infinite tape where each cell stores a single signed integer. The values of the cells follow a periodic pattern. In other words, there exists a period $k$ where the value of any cell at $x$ equals the value of the cell at $x+k$. An Angel v. Devil program is therefore just a list of integers tessellated to fill an infinite tape.

The Angel starts at the first integer in the program, while The Devil starts directly to its left. At each step, The Angel reads the value of its cell and forces The Devil to jump left or right by that amount of cells. The sign of the value determines the movement direction. Positive values force The Devil to move right, while negative values force The Devil to move left. After each step, The Angel will jump right to the next unburned cell.

The Devil will burn every cell it touches. If the Devil manages to reach The Angel's current cell, it will burn The Angel, which results in the system's halt. The Devil's win condition is to burn The Angel, while The Angel's win condition is to evade The Devil indefinitely.

Examples

This program creates an alternating burned-unburned cells pattern.

2

Implementation

Python

A simple Python interpreter for Angel v. Devil can be written in just a few lines of code.

from collections import defaultdict
program = list(map(int, input().strip().split()))
burned = defaultdict(bool)
a, d = 0, -1
while True:
    d += program[a % len(program)]
    burned[d] = True
    if burned[a]:
        break
    a += 1
    while burned[a]:
        a += 1

Here's a more sophisticated interpreter which displays the execution trace.

from collections import defaultdict
maxvis = 0
program = list(map(int, input().strip().split()))
burned = defaultdict(bool)
a, d = 0, -1
def display():
    print(f'{min(a,d)} | ', end="")
    for i in range(min(a,d), maxvis+1):
        if a == i and d == i:
            print(f'<x>', end="")
        elif a == i:
            print(f'({program[i % len(program)]})', end="")
        elif d == i:
            print(f'{{x}}', end="")
        elif burned[i]:
            print(f' x ', end="")
        else:
            print(f' {program[i % len(program)]} ', end="")

    print(f" | {maxvis}")
    print()
display()
while True:
    d += program[a % len(program)]
    burned[d] = True
    maxvis = max(maxvis, d)
    if burned[a]:
        break
    a += 1
    while burned[a]:
        a += 1
    maxvis = max(maxvis, a)
    display()
display()

Computational class

It is currently unknown whether Angel v. Devil is Turing complete or not.