Визначення того, чи є мова Тюрінг завершеною , дуже важливо при розробці мови. Це також досить складне завдання для багатьох езотеричних мов програмування, але, давайте, начебто, це стає на межі. Давайте складемо кілька мов програмування, які настільки важко довести Turing Complete, що навіть кращі математики світу не зможуть їх довести жодним чином. Ваше завдання - розробити та реалізувати мову, повнота Тюрінга спирається на головну невирішену проблему з математики .

Правила

• Вибрана вами проблема повинна бути поставлена ​​щонайменше 10 років тому і повинна бути вирішена на момент розміщення цього питання. Це може бути будь-яка доказна гіпотеза з математики, а не лише одна із перелічених на сторінці Вікіпедії .

• Ви повинні надати специфікацію мови та реалізацію на існуючій мові.

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

• Ви повинні включити доказ того, чому це було б Тюрінг повним або неповним на основі обраної гіпотези. Ви можете припустити доступ до необмеженої пам'яті під час запуску перекладача або складеної програми.

• Оскільки ми стурбовані повнотою Turing, введення-виведення не потрібно, проте мета полягає в тому, щоб зробити найцікавішу мову, щоб це могло допомогти.

• Це змагання за популярність, тому відповідь з найбільшою кількістю голосів виграє.

Цільові критерії

Що має робити хороша відповідь? Ось деякі речі, на які слід звернути увагу при голосуванні, але технічно їх не потрібно

• Це не повинен бути простим виправленням існуючої мови. Зміна існуючої мови відповідно до специфікацій - це добре, але виправлення за умови не рекомендується, оскільки це нудно. Як говориться в ais523 в дев'ятибайтному байті:

  Я вважаю за краще зробити так, щоб мої мозолі езолангів міцніше були викладені на мові

• Це має бути цікаво як окрема езотерична мова.

Легенда

Ця мова є цілковитою лише за Тьюрінгом, якщо і лише тоді, коли гадка Легенда є хибною, тобто існує ціле число 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 / - enableZero, щоб дозволити? для використання, -f / - файл для запуску коду безпосередньо з файлу та -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

Синтаксис

Програми записуються у вигляді набору команд.
Command1 Command2 Command3 ...
Command1 Command2 ...
...

Щоб визначити, чи програма закрита союзом, кожен набір обліковує лише список різних команд, що знаходяться у наборі
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), приріст, декремент, то всі команди є доступними, тож можна моделювати машину Міньського.

Будь-який набір з лише j (x, y), який досягається за допомогою j (x, y) HALT
x ++ є INC
x-- є DEC
j (x, y) - JZ

Якщо припущення закритих наборів об'єднання є правильним, принаймні одна з трьох команд завжди буде відключена, тим самим унеможливлюючи, щоб ця мова була завершеною.

Ферматні праймери

Мова працює на двох потенційно нескінченних стрічках, де кожне розташування стрічки може зберігати довільне ціле число. Обидві стрічки заповнені -1на початку. Також є дві стрічки, які починаються з позиції 0 на обох стрічках.

Перекладач спочатку прочитає вхідні дані та збереже значення у першій стрічці (дані), починаючи з позиції 0.

Потім він прочитає додану програму. Для кожного числа, з яким він стикається, він спочатку перевірить, чи є значення простим Fermat чи ні. Якщо так, то він запише на другу (інструкційну) стрічку, якою є Ферма, інакше він запише -1на стрічку інструкцій.

Далі перевірте значення вказівника інструкції та виконайте одну з наступних дій:

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

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

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

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

Доказ

Зауважте, що мова по суті відображається на інтерпретаторі Brainfuck, що не має IO, де F_5потрібно робити правильні петлі.

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

Впровадження

(випробувано на рубіні 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-й прем'єр Fermat:

17 65537 5 17 ? 257

Ви можете спробувати, що він працює, увімкнувши режим читів і використовуючи 2 4 1 2 5 3в якості вихідного коду:

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

Ластівки ж / кокос v2

Оскільки в попередній версії були помилки, які зробили її недійсною для цього конкурсу, і я не хочу, щоб оновлення від попередньої версії рахувалося за цю версію, яка значно відрізняється, ця версія подається як нова публікація.

Ця мова не є Тюрінг повною, якщо можна довести Collatz Conjecture для всіх натуральних чисел. В іншому випадку мова Тюрінга завершена.

Ця мова була заснована кардиналом .

По-перше, contVal програми обчислюється за формулою
contVal = sum (сума (значення ASCII рядка) * 2 ^ (номер рядка-1))

Далі, на кожному A або E створюються 2 ластівки, спрямовані в протилежні сторони, і всі умовні повороти повороту встановлюються для очікування ініціалізації.
Ластівки, створені на E, головують вліво / вправо, а ластівки, створені на A, спрямовані вгору / вниз.

Нарешті, код буде виконувати дії, поки всі покажчики не будуть видалені або contVal не впаде на один.

На кожному кроці, якщо 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
Змінним доступом: змінні зберігаються як покажчики під час проходження
об'єднання Звернення: шляхом зміни відстані, пройденої до операцій, порядок виконання операцій можна змінити
для циклу: Цією мовою

E   > V
    ^+R
      +
      A

буде діяти для циклу> рахувати до 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): віднімає y від x. за допомогою рядків, видаляє останній len (y) з x

m(x, y): помножує х і у. Якщо використовується з рядками, множимо x разів len y.

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

o(x): друкує х

i(x, y): якщо x оцінюється як істинне, то воно виконує функцію 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): виконує х, тоді у.

Щоб отримати еквівалент 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-й блок коду виконується щоразу, коли лічильник досягає ідеального числа. Якщо існує нескінченна кількість досконалих чисел, воно може циклічити нескінченно довго і Тюрінг завершений, інакше це не так.

Саморозрядний циклічний перекладач тегів, який містить 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). Це спрацьовує в тому, що гіпотеза Легенда є істинною. Кожен оператор повинен впасти на число в гіпотезі Legendre, яку ми починаємо з n = 1. Кожен раз, коли у вас є оператор, ви берете кількість \ n і підключаєте його до конвенції Legendre і отримуєте діапазон, який буде наступним простим розміром \ n повинні обов'язково потрапити. Отже, щоб почати ви робити, \n\nтоді ви переходите до оператора, а \nпотім іншого оператора, ми знаходимося в 3 нових рядках. Тепер наступне - це 5, тож ви додасте \n\nі оператор переконується, що в останньому рядку оператора є потрібна кількість нових рядків, що ви знаходитесь на основній сумі, що впадає в умовність Legendre, яку ми розпочали.

Числа (масив) схожі на змінні. Кожен раз, коли оператор запускає (який використовує числа), він збільшується.

+ 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

Тюрінг повноти

Звичайно, ця проста система може здатися надто простою для імітації повноти Тьюрінга, але виявляється, що будь-яка машина Тьюрінга з двома символами (клас, який включає універсальні машини) може бути перетворена в систему тегів з двома видаленими символами з голови, та 32 * м правила виробництва, де 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 ,