Определение того, является ли язык полным по Тьюрингу, очень важно при разработке языка. Это также довольно трудная задача для многих эзотерических языков программирования, но давайте поднимем ее на ступеньку выше. Давайте создадим некоторые языки программирования, которые так трудно доказать в Turing Complete, что даже лучшие математики в мире не смогут их доказать в любом случае. Ваша задача - разработать и реализовать язык, полнота которого по Тьюрингу зависит от основной нерешенной проблемы математики .

правила

• Выбранная вами проблема должна быть поставлена ​​не менее 10 лет назад и должна быть нерешенной на момент публикации этого вопроса. Это может быть любая доказуемая гипотеза в математике, а не только одна из перечисленных на странице Википедии .

• Вы должны предоставить спецификацию языка и реализацию на существующем языке.

• Язык программирования должен быть завершен по Тьюрингу тогда и только тогда, когда гипотеза верна. (или если и только если гипотеза не верна)

• Вы должны приложить доказательство того, почему оно будет полным или неполным по Тьюрингу на основе выбранной гипотезы. Вы можете получить доступ к неограниченной памяти при запуске интерпретатора или скомпилированной программы.

• Поскольку нас интересует Тьюринг-полнота, ввод-вывод не требуется, однако цель состоит в том, чтобы сделать наиболее интересный язык, чтобы он мог помочь.

• Это конкурс популярности, поэтому победит ответ с наибольшим количеством голосов.

Целевые критерии

Что должен сделать хороший ответ? Вот некоторые вещи, на которые нужно обратить внимание при голосовании, но они не являются технически необходимыми

• Это не должно быть простым патчем существующего языка. Изменение существующего языка в соответствии со спецификациями - это хорошо, но исправление условий не рекомендуется, потому что это скучно. Как сказано в ais523 в байте Nineteeth:

  Я предпочитаю делать уловки моих эсолангов более прочно запеченными в язык

• Это должно быть интересно как самостоятельный эзотерический язык.

Лежандра

Этот язык полон по Тьюрингу только тогда и только тогда, когда гипотеза Лежандра ложна, т. Е. Существует целое число n> 0, такое, что между n ^ 2 и (n + 1) ^ 2 нет простых чисел. Этот язык черпает вдохновение из Underload, хотя в некоторых отношениях он сильно отличается от него.

Программы в Legendre состоят из ряда натуральных чисел (0 особенно запрещено, потому что оно по существу сводит на нет всю цель языка). Каждое целое число соответствует базовой команде в Legendre или потенциальной пользовательской команде. Для какой команды она назначена, зависит от числа простых чисел между ее квадратом и следующим целым числом (эквивалентно последовательности OEIS A014085 ).

Команды языка модифицируют стек, который может содержать произвольно большие положительные целые числа. Если в стеке хранится 0, 0 сразу удаляется. Подробно, команды:

• 2 (наименьшее целое число, производящее эту команду: 1): поместите следующее целое число в программе в стек.

• 3 (наименьшее производящее целое число: 4): вставьте верхнее целое в стек и выполните связанную с ним команду.

• 4 (наименьшее: 6): выведите верхнее целое число. Если это было 1, увеличьте верхнее целое число в стеке.

• 5 (10): поменяйте местами два верхних стека.

• 6 (15): уменьшить верхнее целое в стеке. Если это приводит к 0, вытолкните 0 и отбросьте его.

• 7 (16): дублировать верхнее целое число в стеке.

• 8 (25): остановить выполнение и распечатать содержимое стека.

Это базовый набор команд, который не может делать ничего интересного, не говоря уже о цикле. Однако есть другая команда, к которой можно получить доступ, только если гипотеза Лежандра окажется ложной.

• 0 (неизвестно): удалить все элементы из стека и объединить их в новую функцию, которая будет выполнять все команды, начиная с исходного основания стека и заканчивая сверху, доступный как команда, чей «номер команды» равен следующее целое число в источнике программы соответствует.

Если эта команда каким-то образом доступна, язык становится тьюрингово-полным, так как в ней можно смоделировать машину Минского.

Когда команда 8 выполняется или достигнут конец программы, программа завершается и печатается символ (Unicode), соответствующий каждому целому числу в стеке.

Примеры программ

1 2 1 3 1 10 4

Эта простая программа вводит число 2, затем 3 и, наконец, 10, прежде чем выполнить 4 (команда: 3), что приводит к выталкиванию и выполнению 10 (команда: 5), меняя местами 2 и 3.

1 5 3 15 2 1 6 7

Эта программа демонстрирует использование косвенного целочисленного соответствия между командами. Сначала нажимают 5, затем 15 и 1, используя три разных способа кодирования команды 2. Затем 1 выталкивается, и в результате 15 увеличивается до 16 и, наконец, выполняется. Программа заканчивается двумя экземплярами числа 5 в стеке.

1 1 1 5 ? 24 1 15 1 31 ? 31 24 31

Эта программа демонстрирует использование команды 0, используя? в качестве номера заполнителя. Программа сначала сохраняет «1 5» в функции 9, затем «15 31» в 10, прежде чем запустить функцию 9 (используя 24), которая помещает 5 в стек и многократно уменьшает его, пока не достигнет 0 и не будет удалена , Затем программа останавливается.

Минский автомат

Чтобы преобразовать машину Минского в код Legendre, необходимо использовать команду 0 . Поскольку эта команда недоступна, если гипотеза Лежандра не ложна, я использовал заполнитель? вместо.

Обратите внимание, что все имена строк машинных команд Minsky должны иметь целые числа с различными соответствиями A014085 друг от друга и базовых команд, а также 24 (9) и 31 (10).

1 1 1 1 ? 24

A:

1 y 1 24 1 ? 1 6 1 1 16 1 24 ? x

B:

1 y 1 24 1 ? 1 10 1 6 1 1 16 1 10 1 24 ? x

A:

1 4 1 10 1 15 1 10 1 31 1 1 1 10 1 z 1 1 1 16 1 24 1 31 1 ? 1 24 1 15 1 y 1 6 16 1 24 16 1 ? 1 1 16 1 10 1 1 16 1 24 ? x

B:

1 4 1 10 1 15 1 10 1 31 1 1 1 10 1 z 1 1 1 16 1 24 1 31 1 ? 1 24 1 15 1 10 1 y 1 6 16 1 24 16 1 ? 1 1 16 1 10 1 1 16 1 10 1 24 ? x

1 25 ? x

Чтобы создать конечную программу, добавьте все части (с заменой x, y, z их аналогами) и добавьте одно целое число, чтобы запустить первую инструкцию в цепочке. Это должно доказать полноту по Тьюрингу языка в случае, если гипотеза Лежандра окажется контрпримером ложной.

переводчик

Этот интерпретатор написан на Python (3) и был протестирован на всех трех приведенных выше примерах. Используйте флаги -a / - allowZero, чтобы разрешить? -f / - file для запуска кода непосредственно из файла и -s / - stackOut для вывода стека в виде списка Python. Если файл не указан, интерпретатор входит в режим REPL, который лучше всего использовать с --stackOut.

import sys
import argparse
import io

class I_need_missing(dict): #used to avoid try/except statements. Essentially a dict
    def __missing__(self,key):
        return None 

def appropriate(integer,prev): #returns number of primes between the square of the integer given and the next

    return_value = 0

    if prev[integer]:
        return prev[integer],prev
    if integer == "?":
        return 0,prev
    for i in range(integer ** 2, (integer + 1) ** 2):
        t = False
        if i > 1:
            t = True
            for j in range(2,int(i ** 0.5)+1):
                t = i/j != round(i/j)
                if not t:
                    break
        return_value += t

    prev[integer] = return_value
    return return_value,prev

def run_command(commandseries,stack,functions,prev): #Runs the appropriate action for each command.

    command,prev = appropriate(commandseries.pop(0),prev)

    halt = False

    if command == 0: #store in given number
        functions[appropriate(commandseries.pop(0),prev)[0]] = stack
        stack = []

    elif command == 2:#push
        stack.append(commandseries.pop(0))

    elif command == 3:#execute top instruction
        commandseries.insert(0,stack.pop())

    elif command == 4:#pop, add 1 to new top if popped value was 1
        if stack.pop() == 1:
            stack[-1] += 1

    elif command == 5:#swap top two integers/?
        stack[-1],stack[-2] = stack[-2],stack[-1]

    elif command == 6:#subtract 1 from top of stack
        stack[-1] -= 1
        if stack[-1] == 0:
            stack.pop()

    elif command == 7:#duplicate top of stack
        stack.append(stack[-1])

    elif command == 8:#halt
        halt = True

    else:#run custom
        try:
            commandseries[0:0] = functions[command]
        except TypeError:
            print("Warning: unassigned function " + str(command) + " is unassigned", file = sys.stderr)

    return commandseries,stack,functions,prev,halt

def main(stack,functions,prev):
    #Parser for command line options
    parser = argparse.ArgumentParser(description = "Interpreter for the Legendre esoteric programming language.")
    parser.add_argument("-a","--allowZero", action = "store_true")
    parser.add_argument("-f","--file")
    parser.add_argument("-s","--stackOut", action = "store_true")

    args = parser.parse_args()
    allow_zero = bool(args.allowZero)

    #Program decoding starts
    pre = ""

    if not args.file:
        pre = input()
        if pre == "":
            return
    else:
        pre = open(args.file).read()

    mid = pre.split()
    final = []

    for i in mid:
        if i == "?" and allow_zero:
            final.append("?")
        elif i != 0 or allow_zero: #and allow_zero)
            final.append(int(i))

    halt = False

    #Functional programming at its best
    while final and not halt:
        final,stack,functions,prev,halt = run_command(final,stack,functions,prev)

    #Halting and output
    else:
        if args.stackOut:
            print(stack)
        else:
            for i in stack:
                print(i == "?" and "?" or chr(i),end = "")
            print("")
        if args.file or halt:
            return
        else:
            main(stack,functions,prev)


if __name__ == '__main__':
    main([],I_need_missing(),I_need_missing())

Союз закрыт

Этот язык программирования является полным по Тьюрингу, если гипотеза о замкнутых множествах неверна.

управления

Список команд:
x ++ Увеличение x (INC)
x-- Уменьшение x (DEC)
j (x, y) Добавить набор инструкций x, если y равно 0, до конца очереди инструкций

Все переменные инициализируются как 0

Синтаксис

Программы написаны в виде набора наборов команд.
Команда1 Команда2 Команда3 ... Команда1 Команда2
...
...

Для определения, является ли программа закрытой объединением, каждый набор учитывает только список различных команд, которые находятся в наборе
j (x, y)! = J (a, b)
+ (x)! = + (Y)

Если какой-либо тип команды (+, -, j) присутствует хотя бы в половине наборов, он ничего не делает.

Программы могут завершиться, если в конце очереди команд нет инструкций

Бесконечные циклы, включая пустой цикл, могут быть достигнуты с помощью j (x, y)

переводчик

function union_arrays (x, y) {
  var obj = {};
  for (var i = x.length-1; i >= 0; -- i)
     obj[x[i]] = x[i];
  for (var i = y.length-1; i >= 0; -- i)
     obj[y[i]] = y[i];
  var res = [];
  for (var k in obj) {
    res.push(obj[k]);
  }
  return res;
}



function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  input=input.split("\n").map(a=>a.split(" "));



  input=input.filter(x=>x.filter(y=>y.length>0).length>0);
  for(i=0;i<input.length;i++){
    for(j=0;j<input[i].length;j++){
      switch(input[i][j][0]){
        case"j":
          eval(input[i][j].split(",")[0].slice(2)+"=0;"+input[i][j].split(",")[1].slice(0,-1)+"=0")
          break;
        default:
          eval(input[i][j].slice(0,1)+"=0");
          break;
      }
    }
  }

  counts=[0,0,0];
  for(i=0;i<input.length;i++){
    count=[0,0,0];
    for(j=0;j<input[i].length;j++){
      switch(input[i][j][0]){
        case"j":
          count[2]=1;
          break;
        default:
          if(input[i][j][1]=="+"){
            count[0]=1;
          }
          else{
            count[1]=1;
          }
        break;
      }
    }
    for(j=0;j<3;j++){
      counts[j]+=count[j];
    }
  }
  for(i=0;i<input.length-1;i++){
    for(j=i+1;j<input.length;j++){
      valid=0;
      union=union_arrays(input[i],input[j]);
      for(k=0;k<input.length;k++){
        if(union_arrays(input[k],[]).sort().join("")==union.sort().join("")){
          valid=1;
        }
      }
      if(!valid){
        break;
      }
    }
    if(!valid){
      break;
    }
  }
  console.log(valid)
  var queue=[]
  if(valid){
    queue.push(input[0]);
    while(queue.length){
      for(i=0;i<queue[0].length;i++){
        if(queue[0][i][0]=="j"&&counts[2]<input.length/2){
          eval("if("+queue[0][i].split(",")[1].slice(0,-1)+"===0&&input["+queue[0][i].split(",")[0].slice(2)+"])queue.push(input["+queue[0][i].split(",")[0].slice(2)+"])");
        }
        if(queue[0][i][1]=="+"&&counts[0])
          eval(queue[0][i]);
        if(queue[0][i][1]=="-"&&counts[1])
          eval(queue[0][i]);
      }
      queue=queue.splice(0,1);
    }
  }
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

Полнота по Тьюрингу

Если все три команды, j (x, y), увеличивают, уменьшают, все команды доступны, то есть машина Minsky может быть смоделирована.

Любой набор только с j (x, y), который достигается с помощью j (x, y), равен HALT
x ++, равен INC
x--, DEC
j (x, y) равен JZ

Если гипотеза объединения замкнутых множеств верна, то по крайней мере одна из трех команд всегда будет отключена, что сделает невозможным выполнение этого языка по Тьюрингу.

Ферма простые числа

Язык работает на двух потенциально бесконечных лентах, где каждое местоположение ленты может хранить произвольное целое число. Обе ленты заполняются -1при запуске. Есть также две головки ленты, которые начинаются в позиции 0 на обеих лентах.

Интерпретатор сначала прочитает ввод и сохранит значения на первой ленте (данных), начиная с позиции 0.

Затем он будет читать предоставленную программу. Для каждого встречаемого числа сначала проверяется, является ли значение простым числом Ферма или нет. Если да, он записывает на вторую (командную) ленту, какое это простое число Ферма, в противном случае он записывает -1на ленту с инструкциями.

Затем проверьте значение в указателе инструкций и выполните одно из следующих действий:

• -1 или меньше: выход из программы
• 0: Переместите позицию ленты данных на одну влево. Переместить ленту инструкций на одну позицию вправо
• 1: Переместите ленту данных на одну позицию вправо. Переместить ленту инструкций на одну позицию вправо
• 2: Увеличить значение в позиции ленты данных. Переместить ленту инструкций на одну позицию вправо
• 3: Уменьшить значение в позиции ленты данных. Переместить ленту инструкций на одну позицию вправо
• 4: Если значение в текущей позиции ленты данных равно нулю, перемещайте ленту инструкций вправо, пока не достигнете соответствующего 5(или большего) значения на ленте инструкций или чего-то меньшего, чем 0. Если он 5(или больше), переместите указатель инструкции еще раз вправо, если он меньше, чем 0выйдите из программы. Если значение текущей позиции ленты данных не равно нулю, просто переместите ленту инструкций вправо
• 5или больше: перемещайте указатель инструкций влево, пока не достигнете соответствующего 4значения или не найдете что-то меньше 0. В последнем случае выйдите из программы.

(путем сопоставления 5(или более) и 4значений это означает, что при поиске правильного значения на ленте инструкций в любое время, когда он встречает то же значение, что и исходная команда (либо 5(или более), либо 4)), ему придется пропустить соответствующее число другого значения ( 4или 5(или более) соответственно) в поиске)

Цикл, пока инструкция не говорит, что вы должны выйти из программы.

Когда программа завершает работу, выводите значения на ленте данных с позиции 0до первой позиции на ленте, содержащей -1значение.

доказательство

Обратите внимание, что язык по существу соответствует интерпретатору Brainfuck без ввода-вывода, где F_5требуется, чтобы он мог выполнять любые правильные циклы.

Однако на основе простой гипотезы Ферма есть только 5 простых чисел Ферма ( F_0- F_4). Если F_5существует, то язык полный по Тьюрингу, поскольку мы знаем, что Brainfuck является полным по Тьюрингу. Однако без F_5вас не обойдется ни ветвление, ни зацикливание, по сути, блокирование вас в очень простых программах.

Реализация

(протестировано с ruby ​​2.3.1)

#!/usr/bin/env ruby
require 'prime'

CHEAT_MODE = false
DEBUG_MODE = false
NUM_CACHE = {}

def determine_number(n)
  return n.to_i if CHEAT_MODE
  n = n.to_i
  -1 if n<3

  return NUM_CACHE[n] if NUM_CACHE[n]

  i = 0

  loop do
    num = 2**(2**i) + 1
    if num == n && Prime.prime?(n)
      NUM_CACHE[n] = i
      break
    end
    if num > n
      NUM_CACHE[n] = -1
      break
    end
    i += 1
  end

  NUM_CACHE[n]
end

data_tape = Hash.new(-1)
instruction_tape = Hash.new(-1)

STDIN.read.each_char.with_index { |c,i| data_tape[i] = c.ord }
File.read(ARGV[0]).split.each.with_index do |n,i|
  instruction_tape[i] = determine_number(n)
end

data_pos = 0
instruction_pos = 0

while instruction_tape[instruction_pos] >= 0
  p data_tape, data_pos, instruction_tape, instruction_pos,'------------' if DEBUG_MODE

  case instruction_tape[instruction_pos]
  when 0 then data_pos -= 1; instruction_pos += 1
  when 1 then data_pos += 1; instruction_pos += 1
  when 2 then data_tape[data_pos] += 1; instruction_pos += 1
  when 3 then data_tape[data_pos] -= 1; instruction_pos += 1
  when 4 then
    if data_tape[data_pos] == 0
      count = 1
      instruction_pos += 1
      while count>0 && instruction_tape[instruction_pos] >= 0
        count += 1 if instruction_tape[instruction_pos] == 4
        count -= 1 if instruction_tape[instruction_pos] >= 5
        instruction_pos += 1
      end
      break if count != 0
    else
      instruction_pos += 1
    end
  else
    count = 1
    instruction_pos -= 1
    while count>0 && instruction_tape[instruction_pos] >= 0
      count += 1 if instruction_tape[instruction_pos] >= 5
      count -= 1 if instruction_tape[instruction_pos] == 4
      instruction_pos -= 1 if count>0
    end
    break if count != 0
  end
end

data_pos = 0

while data_tape[data_pos] >= 0
  print data_tape[data_pos].chr
  data_pos += 1
end

Примеры:

Это напишет H(сокращенно Hello World!) на экран с новой строкой:

17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17
5
17 17 17 17 17 17 17 17 17 17
17

Сохраните как example.fermatи запустите его так (примечание: вы всегда должны иметь данные):

$ echo -n '' | ./fermat.rb example.fermat

В следующем примере мы сделаем простой шифр в стиле Цезаря, увеличив каждое значение на единицу. Вы, очевидно, должны заменить ?на 5-е простое число Ферма:

17 65537 5 17 ? 257

Вы можете попробовать, что он работает, включив чит-режим и используя 2 4 1 2 5 3в качестве исходного кода:

$ echo 'Hello' | ./fermat.rb example2_cheat.fermat

Ласточки с кокосом v2

Поскольку в предыдущей версии были ошибки, которые сделали ее недействительной для этого конкурса, и я не хочу, чтобы количество голосов предыдущей версии для этой версии значительно отличалось, эта версия представляется как новое сообщение.

Этот язык не является полным по Тьюрингу, если гипотеза Коллатца может быть доказана для всех натуральных чисел. В противном случае язык Тьюринга завершен.

Этот язык был основан на кардинал .

Во-первых, управление программой рассчитывается по формуле
contVal = sum (сумма (значения ASCII строки) * 2 ^ (номер строки-1))

Затем в каждой точке A или E создаются 2 ласточки, движущиеся в противоположных направлениях, и все операторы условного поворота устанавливаются для ожидания инициализации.
Ласточки, созданные в E, направляются влево / вправо, а ласточки, созданные в A, направляются вверх / вниз.

Наконец, код будет выполнять шаги, пока все указатели не будут удалены или контроль не упадет до одного.

На каждом шаге, если contVal% 2 == 0, он будет делиться на 2, в противном случае он будет умножен на три и увеличен на единицу.

Команды:

0: установить значение 0
+: увеличить значение на 1
>: изменить направление вправо
v: изменить направление вниз
<: изменить направление влево
^: изменить направление вверх
R: последующие указатели после первого указателя сравниваются со значением первый указатель Если равны, идите прямо, иначе поверните направо.
L: последующие указатели после первого указателя сравниваются со значением первого указателя. Если равны, идите прямо, иначе поверните налево.
E: Дублировать указатель, но в направлениях влево и вправо
A: Дублировать указатель, но в направлениях вверх и вниз
? : Удалить указатель, если значение равно 0

function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  area=input.split('\n');
  width=0;
  height=area.length;
  for(i=0;i<height;i++){
    width=Math.max(width,area[i].length);
  }
  //Determine the endurance of the swallows
  contVal=0;
  for(i=0;i<height;i++){
    for(j=0;j<area[i].length;j++){
      contVal+=((j+1)<<i)*area[i].charCodeAt(j);
    }
  }
  //Spawn the African and European swallows and initialize the conditionals
  pointerList=[];
  condList=[];
  for(i=0;i<height;i++){
    for(j=0;j<area[i].length;j++){
      if(area[i][j]=='A'){
        pointerList.push([i,j,0,0]);
        pointerList.push([i,j,2,0]);
      }
      if(area[i][j]=='E'){
        pointerList.push([i,j,1,0]);
        pointerList.push([i,j,3,0]);
      }
      if(area[i][j]=='R'||area[i][j]=='L'){
        condList.push([i,j,-1]);
      }
    }
  }
  output='';
  while(1){
    for(i=0;i<pointerList.length;i++){
      switch (pointerList[i][2]){
        case 0:
          pointerList[i][1]++;
          break;
        case 1:
          pointerList[i][0]++;
          break;
        case 2:
          pointerList[i][1]--;
          break;
        case 3:
          pointerList[i][0]--;
          break;
      }
      if(pointerList[i][1]<0||pointerList[i][0]<0||pointerList[i][0]>=height||pointerList[i][1]>=area[pointerList[i][0]].length){
        pointerList.splice(i,1);
      }
      else{
        switch(area[pointerList[i][0]][pointerList[i][1]]){
          case "+":
            pointerList[i][3]++;
            break;
          case "0":
            pointerList[i][3]=0;
            break;  
          case ">":
            pointerList[i][2]=1;
            break;
          case "v":
            pointerList[i][2]=2;
            break;
              case "<":
            pointerList[i][2]=3;
            break;
          case "^":
            pointerList[i][2]=0;
            break;
          case "R":
            for(j=0;j<condList.length;j++){
              if(pointerList[i][0]==condList[j][0]&&pointerList[i][1]==condList[j][1]){
                if(condList[j][2]==-1){
                  condList[j][2]=pointerList[i][3];
                  pointerList.splice(i,1);
                }
                else{
                  if(pointerList[i][3]!=condList[j][2]){
                    pointerList[i][2]=(pointerList[i][2]+1)%4;
                  }
                }
              }
            }
            break;
          case "L":
            for(j=0;j<condList.length;j++){
              if(pointerList[i][0]==condList[j][0]&&pointerList[i][1]==condList[j][1]){
                if(condList[j][2]==-1){
                  condList[j][2]=pointerList[i][3];
                  pointerList.splice(i,1);
                }
                else{
                  if(pointerList[i][3]!=condList[j][2]){
                    pointerList[i][2]=(pointerList[i][2]+3)%4;
                  }
                }
              }
            }
            break;
          case "A":
            pointerList.push([pointerList[i][0],pointerList[i][1],0,pointerList[i][3]]);
            pointerList.push([pointerList[i][0],pointerList[i][1],2,pointerList[i][3]]);
            break;
          case "E":
            pointerList.push([pointerList[i][0],pointerList[i][1],1,pointerList[i][3]]);
            pointerList.push([pointerList[i][0],pointerList[i][1],3,pointerList[i][3]]);
            break;
          case "?":
            pointerList.splice(i,1);
        }
      }
    }
    if(contVal%2===0){
      contVal=contVal/2;
    }
    else{
      contVal=contVal*3+1;
    }
    if(!pointerList.length||contVal==1){
      break;
    }
  }
  console.log(output);
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

Объяснение:

Если гипотеза Коллатца может быть доказана для всех натуральных чисел, длительность любой программы, выполняемой на этом языке, конечна, так как contVal всегда будет сходиться к 1, тем самым завершая программу.

В противном случае мне просто нужно доказать, что этот язык может реализовывать следующие функции

Инкремент: который представлен +
константой 0: который представлен 0
Доступ к переменной: переменные сохраняются в виде указателей при их перемещении.
Конкатенация операторов: изменяя расстояние, пройденное до операций, можно изменить порядок выполнения операций.
Цикл For: На этом языке

E   > V
    ^+R
      +
      A

будет действовать как цикл for> count до 1 (дальнейший код может быть добавлен в цикл)

Точно так же код

Rv
^<

Будет действовать до тех пор, пока не станет равным условному значению, заданному в цикле R.

Совершенство / Несовершенство

Вот это было весело.

Совершенство / Несовершенство завершается только при наличии бесконечных совершенных чисел. Если есть, это называется Совершенство, а если нет, это называется Несовершенство. Пока эта тайна не разгадана, она держит оба имени.

Совершенное число - это число, сумма делителей которого равна числу, поэтому шесть - это идеальное число, потому что 1+2+3=6.

Совершенство / Несовершенство имеет следующие функции:

Совершенство / Несовершенство основано на стеке, с индексированным стеком.

Команды:

p(x, y): выталкивает x в стек в y-й позиции.

z(x, y): выталкивает x в стек в y-й позиции, избавляется от того, что было ранее в y-й позиции

r(x): удаляет x-й элемент из стека

k(x): возвращает x-й элемент в стеке

a(x, y): добавляет х и у. При использовании со строками он складывает их в порядке xy.

s(x, y): вычитает у из х. со строками, удаляет последний len (y) из x

m(x, y): умножает x и y. Если используется со строками, умножается в x раз на len y.

d(x, y): делит х на у

o(x): печатает х

i(x, y): если x имеет значение true, тогда он выполняет функцию y

n(): возвращает счетчик, на котором вызывается кодовый блок.

q(): возвращает длину стека

t(): пользовательский ввод

e(x, y): Если x является целым числом, если x и y имеют одно и то же значение, то это возвращает 1. Если y является строкой, то она получает длину y. если x является строкой, то он преобразует y в строку и проверяет, совпадают ли они, и, если они есть, возвращает 1. В противном случае возвращается 0.

l(x, y): если x больше, чем y, он возвращает 1. Если есть строка, то она использует длину строки.

b(): останавливает программу.

c(x, y): работает x, затем y.

Чтобы получить эквивалент Python and, умножьте два значения вместе. Для or, добавьте значения, и для not, вычтите значение из 1. Это работает, только если значение равно 1 или 0, что может быть достигнуто путем деления числа на себя.

Типы данных: целые числа и строки. Строки обозначены '', а все нецелые числа округлены.

Синтаксис:

Код состоит из вложенных функций внутри десяти {}с. Например, программа , которая получит на входы и распечатать их добавили бы: {o(a(t(), t()))}. На заднем плане программы есть счетчик, который начинается с 0 и прогрессирует на 1 каждый раз, когда он выполняет блок кода. Первый блок кода работает в 0и так далее. После выполнения десяти кодовых блоков шестой выполняется каждый раз, когда счетчик достигает идеального числа. Вам не нужно иметь все десять блоков кода для работы программы, но вам нужно 7, если вы хотите сделать цикл. Чтобы лучше понять , как работает этот язык, запустите следующую программу, которая печатает счетчик каждый раз , когда счетчик достигает совершенное число: {}{}{}{}{}{}{o(n())}.

Переводчик можно найти здесь: repl.it/GL7S/37 . Либо выберите 1 и введите свой код в терминале, либо вставьте код на code.perfectвкладке и выберите 2 при запуске. Это будет иметь смысл, когда вы попробуете это.

Доказательство полноты по Тьюрингу / отсутствие полноты по Тьюрингу.

Согласно этой статье об обмене стеками разработки программного обеспечения , завершение Тьюринга должно иметь возможность условного повторения перехода и иметь возможность чтения или записи в память. Он может считывать / записывать память в виде стека и выполнять цикл из-за того, что 6-й кодовый блок выполняется каждый раз, когда счетчик достигает идеального числа. Если существует бесконечное число совершенных чисел, оно может бесконечно зацикливаться и является полным по Тьюрингу, в противном случае это не так.

Интерпретатор Self Bitwise Cyclic Tag, который принимает 5 символов, 1 или 0, в качестве входных данных:

{p(t(),0)}{(p(t(),0)}{p(t(),0)}{p(t(),0)}{p(t(),0)}{p(0,0)}{c(i(e(k(s(q(),k(0))),0),c(r(q()),i(l(k(0),0),z(s(k(0),1),0)))),i(e(k(s(q(),k(0))),1),c(z(a(k(0),1),0),i(e(k(q()),1),p(k(s(q(),k(0))),1)))))}

Его можно расширить, чтобы принимать любое количество символов в качестве входных данных. Это может занять бесконечный ввод, но только если есть бесконечные совершенные числа!

Подошвы

Этот язык программирования является полным по Тьюрингу, если гипотеза Шольца верна.

Я написал этот язык, потому что @SztupY говорил, что не будет никаких результатов, которые полагаются на гипотезу, чтобы быть правдой, чтобы быть завершенным по Тьюрингу

Список команд

+(x)      Increment x (INC)   
-(x)      Decrement x (DEC)  
j(x,y)    Jump to instruction x if y is 0 (JZ)  
x         End program (HALT) 

С помощью этих команд этот язык может симулировать машину Минского.

переводчик

Я очень рекомендую не запускать это. Он использует чрезвычайно медленный метод проверки цепочки сложений.

function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  input=input.split(" ");
  counter=1;
  lvals=[0];

  l=(x,arr)=>{
    if(arr[x-1]){
      return arr[x-1];
    }
    minim=Number.MAX_SAFE_INTEGER;
    console.log(min);
    for(i=Math.floor(x/2);i>0;i--){
      minim=Math.min(minim,l(i,arr)+l(x-i,arr)+1);
    }
    return minim;
  };
  cont=1;
  pointer=0;
  while(cont){
    lvals[Math.pow(2,counter)-2]=l(Math.pow(2,counter)-1,lvals);
    lvals[counter-1]=l(counter,lvals);
    if(lvals[Math.pow(2,counter)-2]>n-1+lvals[counter-1]){
      break;
    }
    switch(input[pointer][0]){
      case "+":
        x=input[pointer].slice(2,-1);
        eval(x+"++")
        break;
      case "-":
        x=input[pointer].slice(2,-1);
        eval(x+"--")
        break;
      case "j":
        x=input[pointer].split(",")[0].slice(2);
        y=input[pointer].split(",")[0].slice(0,-1);
        eval("if(!"+y+")pointer="+x+"-1");
        break;
      case "x":
        cont=0;
        break;
    }
    pointer++;
    if(pointer>input.length){
      break;
    }
    counter++;
  }
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

Полнота по Тьюрингу

В языке используется счетчик количества запускаемых команд, который он проверяет на соответствие гипотезе Шольца, чтобы изменить полноту тьюринга языка.

Если гипотеза Шольца верна, эта программа работает точно так же, как обычная машина Минского, с
инкрементным
скачком уменьшения
при нулевой
остановке

Однако, если гипотеза Шольца ложна, счетчик в конечном итоге достигнет значения, для которого гипотеза Шольца не верна. Поскольку язык предназначен для выхода при достижении числа, для которого гипотеза Шольца ложна, программа будет выходить каждый раз после выполнения такого количества команд. Поэтому все программы будут иметь ограниченную длину. Поскольку это не соответствует требованиям, предъявляемым к языку, который должен быть завершен по Тьюрингу,

«Лента не может быть фиксированной по длине, поскольку она не будет соответствовать данному определению и серьезно ограничит диапазон вычислений, которые машина может выполнить, с линейным ограниченным автоматом»,

язык не будет полным по Тьюрингу, если гипотеза Шольца будет ложной

Обрученные

Обрученный Гитхуб .

Файл readme и спецификация находятся на github, в разделе "README.txt".

Как правило, программа обручения состоит из пар линий, длина которых представляет собой отдельные пары с двумя простыми числами или пары с обручением (дубликатов быть не может). Программа выполняется путем поиска «гибких подмножеств» первой строки в паре во второй строке. Количество таких подмножеств в сочетании с левенштейновым расстоянием между исходной второй строкой и второй строкой без податливых подмножеств определяют команду для выполнения.

Я приведу выдержку из этого поста:

V. PROOF OF TURING COMPLETENESS

Now, no language can be Turing Complete with bounded program size. Therefore, if Betrothed
is Turing Complete, it must have unbounded program size. Since the lengths of the lines of
a Betrothed program must be twin prime pairs or betrothed pairs, and since both sequences
are unproven to be infinite or finite, Betrothed has unbounded program size if and only if
there are infintie betrothed pairs, there are infinite twin prime pairs, or both.

    Next: to prove that if Betrothed has an unbounded program size, then it is Turing
Complete. I will use the op-codes from the above table to demonstrate key factors of a
Turing Complete language; they are of the form  [index]<[ld]> .

  1. Conditional goto: 6<> 5<>, or if-popjump. This can be used to form a loop.
  2. Inequality to a constant K: 10<K> 
  3. Arbitrarily large variable space: you can use some separator constant C.

    With this, I have sufficient reason to believe that Betrothed is Turing Complete.

Дружное соотношение

Этот язык основан на том, существуют ли какие-либо дружные числа с противоположной четностью .

команды

x : End program if not on top line  
+ : increment stored value  
- : decrement stored value  
{ : set next goto x value to current x value
} : goto previous x value set by {  
j : Go down one line if the special value is an amicable number and the
    parity is opposite to the matching number (loops back to top). If the
    special value is not an amicable number and not on the top line, go up
    one line.  

Контроль потока

Программа циклически повторяется слева направо, а затем возвращается к началу. Если он встречает «j», он проверяет значение, чтобы определить, следует ли ему менять строки. Если число является дружественным числом с четностью, противоположной его совпадению, оно уменьшается на одну строку (возвращаясь к началу). В противном случае, если число является дружественным числом, оно поднимается на одну строку, если его еще нет в верхней строке.

Программа может завершиться только в том случае, если программа достигает x в любом ряду за пределами верхнего ряда.

Полнота по Тьюрингу

Эта программа может использоваться для моделирования машины Минского, предполагая, что есть пара дружных чисел с противоположной четностью.

j, {и} можно использовать для имитации JZ (r, x), хотя он будет проверять наличие дружных чисел, а не нуля.
+ - это INC (r)
- это DEC (r)
x - это HALT

Если вы не можете покинуть первый ряд, команды x и} ничего не делают. Это приводит к тому, что программа не может войти в состояние HALT, если она не является пустой программой. Следовательно, согласно описанию, что для полноты по Тьюрингу требуется состояние HALT , язык будет неполным по Тьюрингу.

переводчик

sumDiv=r=>{
  sum=0;
  for(i=1;i<=Math.sqrt(r)&&i!=r;i++){
    if(r%i===0){
      sum+=i+r/i;
    }
    if(i*i==r){
      sum-=i;
    }
  }
  return sum;
};
function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  input=input.split("\n");
  val=2;
  exit=0;
  loop=0;
  for(j=0;!exit;){
    for(i=0;i<input[j].length;i++){
      if(input[j][i]=="x"&&j){
        exit=1;
        break;
      }
      else if(input[j][i]=="j"){
        if(val==sumDiv(sumDiv(val))&&val!=sumDiv(val)&&(val+sumDiv(val))%2){
          j=(j+1)%input.length;
          i--;
        }
        else if(j&&val!=sumDiv(sumDiv(val))){
          j--;
          i--;
        }
      }
      else if(input[j][i]=="+"){
        val++;
      }
      else if(input[j][i]=="-"){
        val--;
      }
      else if(input[j][i]=="{"){
        loop=i;
      }
      else if(input[j][i]=="}"&&j){
        i=loop;
      }
      if(input[j].length==i+1){
        i=-1;
      }
    }
  }
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

Новая линия

Отказ от ответственности: это немного беспорядок и довольно просто. Это первый язык, который я когда-либо писал, и гипотеза - единственная, которую я понял. Я знаю, что у другого пользователя был более длинный ответ с тем же, но я все равно решил написать это.

Чтобы писать в Newline, у вас должно быть много времени и новых строк ( \n). Это работает на основе гипотезы Лежандра. Каждый оператор должен попадать в число в гипотезе Лежандра, которое мы начинаем с n = 1. Каждый раз, когда у вас есть оператор, вы берете количество \ n и вставляете его в гипотезу Лежандра и получаете диапазон, следующий за следующим простым числом \ n должны войти. Итак, для начала \n\nвы переходите к оператору, а \nзатем к другому оператору, мы находимся на 3 новых строках. Теперь следующий - это 5, так что вы добавляете \n\nи включаете оператор, чтобы убедиться, что последняя строка оператора имеет правильное количество новых строк, что вы находитесь на простом количестве, которое попадает в гипотезу Лежандра, которую мы начали.

Числа (массив) похожи на переменные. Каждый раз, когда оператор запускается (использует числа), он увеличивается.

+ adds
- subtracts
/ divide
* multiply 
s sqrt
% mod
a push to vars
g sets stack to numbers
q pushes value of stack to numbers
i increment 
d decrement
r stops subtraction at 0
w turns back on subtraction past 0
[ starts loop
] ends loop runs until stack is 0
{ starts loop
} ends loop and loops until loops[ln] is 0
k increment loops

Пока у нас есть неограниченное число простых чисел, которые следуют правилам, этот язык имеет бесконечную ленту.

Минский автомат

\n\ng\nr\n\n[\n\nd\n\n\n\n]

Как это устроено:

\n\ng     # the first two newlines are to get to a prime number of newlines (2) then sets the value of stack to the first variable in the array numbers (see code in link)

\nr       # gets to the next number and makes it so subtraction stops at 0

\n\n[     # starts the loop

\n\nd     # decrements stack 

\n\n\n\n] # ends loop

Попробуйте это на KhanAcademy .

Taggis

Taggis - это язык, основанный на системах тегов .

Тьюринговая полнота Таггиса основана на гипотезе Коллатца

Синтаксис

Синтаксис программы Taggis - это просто три строки (производственные правила), состоящие полностью из букв a, b и c, разделенных пробелами.

выполнение

Единственное состояние программы Taggis - это строка, состоящая из тех же трех символов.

Taggis реализует систему тегов TS (3, 2), в которой на каждом шаге удаляются первые 2 буквы текущего «тега», а к самой первой букве, которая была в этой удаленной части, добавляется соответствующее производственное правило, добавляемое в конец строка.

Например, программа Taggis bc a aaaреализует задачу 3n + 1, где итерации представлены соответствующим числом as, а шаг 3n + 1 заменяется на (3n + 1) / 2 [1], что приводит к выводу программы:

aaa // 3
  abc
    cbc
      caaa
        aaaaa // 5
          aaabc
            abcbc
              cbcbc
                cbcaaa
                  caaaaaa
                    aaaaaaaa // 8
                      aaaaaabc
                        aaaabcbc
                          aabcbcbc
                            bcbcbcbc
                              bcbcbca
                                bcbcaa
                                  bcaaa
                                    aaaa // 4
                                      aabc
                                        bcbc
                                          bca
                                            aa // 2
                                              bc
                                                a // 1 and halt because we then begin an infinite loop
                                                 HALT

Полнота по Тьюрингу

Конечно, эта простая система может показаться слишком простой, чтобы эмулировать полноту Тьюринга, но оказывается, что любая машина Тьюринга с 2 символами (класс, включающий универсальные машины) может быть преобразована в систему тегов с 2 удаленными символами из головы, и 32 * m правил производства, где mчисло состояний в машине Тьюринга.

Наименьшая известная универсальная машина Тьюринга, содержащая только 2 символа, использует 18 состояний, и, следовательно, соответствующая система тегов содержит колоссальные 576 правил производства [2].

Однако вычислительный класс множества всех систем тегов с 3 продукцией и 2 удаленными символами связан с гипотезой Коллатца [2]. Если гипотеза Коллатца окажется ложной, то Таггис полон по Тьюрингу. Иначе, это основано на ДРУГОЙ нерешенной проблеме в математике, находя меньшую машину Тьюринга, чем

def taggis(inp, a, b, c):
    current = inp
    seen = set()
    while True:
        seen.add(tuple(current))

        yield current

        head = current[0]

        current = current[2:]

        current.extend([a, b, c][head])

        if tuple(current) in seen:
            return

def parse():
    program = input().split(" ")

    assert len(program) == 3, "There has to be exactly 3 production rules!" 

    productions = []

    for production in program:

        production = [{"a": 0, "b": 1, "c": 2}[x] for x in production]
        productions.append(production)  

    program_input = [{"a": 0, "b": 1, "c": 2}[x] for x in input()]

    k = 0   

    for step in taggis(program_input, *productions):
        print(' ' * k +''.join(['abc'[x] for x in step]))

        k += 2
    print(' ' * (k - 1) + 'HALT')

parse()

1. что эквивалентно исходной функции Коллатца, так как 3n + 1 нечетного nвсегда будет четным, и, следовательно, деление может быть применено автоматически

2. Системы тегов и коллатц-подобные функции, Liesbeth De Mol ,