Menentukan apakah Bahasa Turing Lengkap sangat penting ketika merancang bahasa. Ini juga merupakan tugas yang cukup sulit bagi banyak bahasa pemrograman esoteris untuk memulai, tetapi mari kita mulai saja. Mari kita membuat beberapa bahasa pemrograman yang begitu sulit untuk dibuktikan Turing Lengkap sehingga bahkan ahli matematika terbaik di dunia akan gagal membuktikannya dengan cara apa pun. Tugas Anda adalah menyusun dan mengimplementasikan bahasa yang Kelengkapan Turing bergantung pada masalah utama yang belum terpecahkan dalam Matematika .

Aturan

• Masalah yang Anda pilih harus diajukan setidaknya 10 tahun yang lalu dan harus dipecahkan, sejak posting pertanyaan ini. Ini bisa berupa dugaan yang bisa dibuktikan dalam matematika, bukan hanya salah satu dari yang terdaftar di halaman Wikipedia .

• Anda harus memberikan spesifikasi bahasa dan implementasi dalam bahasa yang ada.

• Bahasa pemrograman harus Turing lengkap jika dan hanya jika dugaan itu berlaku. (atau jika dan hanya jika dugaan tidak berlaku)

• Anda harus menyertakan bukti mengapa Turing lengkap atau tidak lengkap berdasarkan dugaan yang dipilih. Anda dapat mengasumsikan akses ke memori tidak terbatas ketika menjalankan interpreter atau program yang dikompilasi.

• Karena kita prihatin dengan Turing Completeness I / O tidak diperlukan, namun tujuannya adalah untuk membuat bahasa yang paling menarik sehingga dapat membantu.

• Ini adalah kontes popularitas sehingga jawaban dengan suara terbanyak akan menang.

Kriteria Target

Apa yang harus dilakukan dengan jawaban yang baik? Berikut adalah beberapa hal yang harus dicari ketika memilih tetapi tidak secara teknis diperlukan

• Seharusnya bukan tambalan sederhana dari bahasa yang ada. Mengubah bahasa yang ada agar sesuai dengan spesifikasinya baik-baik saja tetapi menambal dengan syarat tidak disarankan karena membosankan. Seperti yang dikatakan oleh ais523 dalam Nineteeth Byte:

  Saya lebih suka membuat gimmick esolang saya lebih kuat dimasukkan ke dalam bahasa

• Itu harus menarik sebagai bahasa esoterik mandiri.

Legendre

Bahasa ini hanya menyelesaikan-Turing jika dan hanya jika dugaan Legendre salah, yaitu terdapat bilangan bulat n> 0 sehingga tidak ada bilangan prima antara n ^ 2 dan (n + 1) ^ 2. Bahasa ini mengambil beberapa inspirasi dari Underload, meskipun dalam beberapa hal sangat berbeda dari itu.

Program di Legendre terdiri dari serangkaian bilangan bulat positif (0 khususnya dilarang, karena pada dasarnya meniadakan seluruh tujuan bahasa). Setiap integer sesuai dengan perintah dasar di Legendre, atau yang potensial yang ditentukan pengguna. Perintah yang ditugaskan padanya didasarkan pada jumlah bilangan prima antara kuadratnya dan bilangan bulat berikutnya (setara dengan urutan OEIS A014085 ).

Perintah bahasa memodifikasi tumpukan, yang dapat menampung bilangan bulat positif besar yang sewenang-wenang. Jika tumpukan pernah menampung 0, 0 segera dihapus. Secara rinci, perintahnya adalah:

• 2 (integer terkecil yang menghasilkan perintah ini: 1): Dorong integer berikutnya dalam program ke stack.

• 3 (integer penghasil terkecil: 4): Letakkan integer atas pada stack dan jalankan perintah yang terkait dengannya.

• 4 (terkecil: 6): Pop the top integer. Jika itu 1, tambahkan bilangan bulat atas di tumpukan.

• 5 (10): Tukar dua item tumpukan teratas.

• 6 (15): Kurangi integer atas pada tumpukan. Jika hasilnya 0, pop 0 dan buang.

• 7 (16): Gandakan bilangan bulat atas pada tumpukan.

• 8 (25): Menghentikan eksekusi dan mencetak konten tumpukan.

Ini adalah set instruksi dasar, yang tidak dapat melakukan sesuatu yang menarik, apalagi perulangan. Namun, ada perintah lain, yang dapat diakses hanya jika dugaan Legendre terbukti salah.

• 0 (tidak diketahui): Hapus semua item dari stack dan gabungkan mereka ke dalam fungsi baru, yang akan menjalankan semua perintah mulai dari dasar asli stack dan berakhir di atas, dapat diakses sebagai perintah yang "nomor perintah" sama dengan yang integer berikutnya dalam sumber program sesuai dengan.

Jika perintah ini entah bagaimana dapat diakses, bahasa menjadi Turing-lengkap, karena seseorang dapat mensimulasikan mesin Minsky di dalamnya.

Ketika perintah 8 dijalankan atau akhir dari program tercapai, program berakhir dan karakter (Unicode) yang sesuai dengan setiap bilangan bulat pada tumpukan dicetak.

Contoh program

1 2 1 3 1 10 4

Program sederhana ini mendorong angka 2, kemudian 3 dan akhirnya 10, sebelum mengeksekusi 4 (perintah: 3), yang menyebabkan 10 (perintah: 5) muncul dan dieksekusi, menukar 2 dan 3.

1 5 3 15 2 1 6 7

Program ini menunjukkan penggunaan korespondensi integer-ke-perintah tidak langsung. Pertama, 5 ditekan, lalu 15 dan 1, menggunakan tiga cara pengkodean 2 perintah yang berbeda. Kemudian, angka 1 muncul dan hasilnya, angka 15 bertambah menjadi angka 16, dan akhirnya dieksekusi. Program berakhir dengan dua contoh nomor 5 pada tumpukan.

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

Program ini menunjukkan penggunaan perintah 0, menggunakan? sebagai nomor pengganti. Program pertama-tama menyimpan '1 5' di fungsi 9, lalu '15 31 'di 10, sebelum menjalankan fungsi 9 (menggunakan 24), yang mendorong 5 ke tumpukan, dan berulang kali menurunkannya, hingga mencapai 0 dan dihapus . Kemudian, program terhenti.

Mesin Minsky

Untuk mengonversi mesin Minsky ke kode Legendre, perintah 0 harus digunakan. Karena perintah ini tidak dapat diakses kecuali dugaan Legendre salah, saya telah menggunakan pengganti? sebagai gantinya.

Perhatikan bahwa semua nama jalur instruksi mesin Minsky harus memiliki bilangan bulat dengan korespondensi A014085 yang berbeda satu sama lain dan perintah dasar serta 24 (9) dan 31 (10).

1 1 1 1 ? 24

SEBUAH:

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

SEBUAH:

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

Untuk membuat program akhir, tambahkan semua bagian (dengan x, y, z digantikan oleh rekan-rekan mereka) dan tambahkan bilangan bulat tunggal untuk memulai instruksi pertama dalam rantai. Ini harus membuktikan kelengkapan Turing bahasa dalam kasus dugaan Legendre terbukti salah dengan contoh balik.

Penerjemah

Penerjemah ini ditulis dengan Python (3), dan telah diuji pada ketiga contoh di atas. Gunakan flag -a / - allowZero untuk mengizinkan? untuk digunakan, -f / - file untuk menjalankan kode langsung dari file dan -s / - stackOut untuk menampilkan stack sebagai daftar Python. Jika tidak ada file yang diberikan, interpreter memasuki semacam mode REPL, yang paling baik digunakan dengan --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())

Serikat Tertutup

Bahasa pemrograman ini Turing lengkap jika dugaan Set Serikat-tertutup tidak benar.

Kontrol

Daftar Perintah:
x ++ Increment x (INC)
x-- Decrement x (DEC)
j (x, y) Tambahkan set instruksi x jika y adalah 0 hingga akhir antrian instruksi

Semua variabel diinisialisasi sebagai 0

Sintaksis

Program ditulis sebagai seperangkat perintah.
Command1 Command2 Command3 ...
Command1 Command2 ...
...

Untuk menentukan apakah program ditutup dengan gabungan, setiap set hanya bertanggung jawab atas daftar perintah berbeda yang ada di set
j (x, y)! = J (a, b)
+ (x)! = + (Y)

Jika ada jenis perintah (+, -, j) muncul di setidaknya setengah set, itu tidak melakukan apa-apa.

Program dapat berakhir jika tidak ada instruksi di ujung antrian instruksi

Loop tak terbatas, termasuk loop kosong, dapat dicapai menggunakan j (x, y)

Penerjemah

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>

Turing Kelengkapan

Jika ketiga perintah, j (x, y), increment, decrement semua perintah tersedia, sehingga mesin Minsky dapat disimulasikan.

Setiap set dengan hanya j (x, y) yang dicapai menggunakan j (x, y) adalah HALT
x ++ adalah INC
x-- adalah DEC
j (x, y) adalah JZ

Jika serikat tertutup menetapkan dugaan itu benar, setidaknya satu dari tiga perintah akan selalu dinonaktifkan, sehingga membuat bahasa ini tidak mungkin untuk menyelesaikan Turing.

Bilangan prima kulit

Bahasa ini berfungsi pada dua kaset yang berpotensi tak terbatas, di mana setiap lokasi rekaman itu dapat menyimpan bilangan bulat sewenang-wenang. Kedua kaset diisi dengan -1di awal. Ada juga dua kepala kaset yang mulai pada posisi 0 pada kedua kaset.

Juru bahasa pertama akan membaca input, dan menyimpan nilai-nilai ke dalam rekaman (data) pertama, mulai dari posisi 0.

Kemudian akan membaca program yang disediakan. Untuk setiap nomor yang dihadapinya, pertama-tama akan memeriksa apakah nilainya merupakan prime Fermat atau tidak. Jika ya, itu akan menulis ke rekaman (instruksi) kedua yang merupakan Fermat prima, jika tidak maka akan menulis -1ke rekaman instruksi.

Selanjutnya periksa nilai pada penunjuk instruksi, dan lakukan salah satu hal berikut ini:

• -1 atau kurang: Keluar dari program
• 0: Pindahkan posisi rekaman data satu ke kiri. Pindahkan pita instruksi satu ke kanan
• 1: Pindahkan posisi rekaman data satu ke kanan. Pindahkan pita instruksi satu ke kanan
• 2: Meningkatkan nilai pada posisi rekaman data. Pindahkan pita instruksi satu ke kanan
• 3: Kurangi nilai pada posisi rekaman data. Pindahkan pita instruksi satu ke kanan
• 4: Jika nilai pada posisi rekaman data saat ini adalah nol, kemudian pindahkan pita instruksi ke kanan, hingga Anda mencapai nilai yang cocok 5(atau lebih besar) pada pita instruksi, atau sesuatu yang lebih kecil dari 0. Jika itu adalah 5(atau lebih besar), pindahkan penunjuk instruksi ke kanan sekali lagi, jika itu lebih kecil daripada 0kemudian keluar dari program. Jika nilai posisi rekaman data saat ini tidak nol, cukup pindahkan pita instruksi satu ke kanan
• 5atau lebih: Pindahkan penunjuk instruksi ke kiri, sampai Anda mencapai nilai yang sesuai 4, atau Anda menemukan sesuatu yang kurang 0. Dalam kasus yang terakhir, keluar dari program.

(dengan mencocokkan 5(atau lebih) dan 4nilai - nilai itu berarti bahwa ketika mencari nilai yang tepat pada pita instruksi setiap kali ia menemukan nilai yang sama dengan perintah awal (baik 5(atau lebih) atau 4), ia harus melewati angka yang sesuai dari nilai lain ( 4atau 5(atau lebih) masing-masing) pada pencarian)

Loop, sampai instruksi mengatakan Anda harus keluar dari program.

Ketika program keluar, output nilai pada rekaman data dari posisi 0hingga posisi rekaman pertama yang berisi -1nilai.

Bukti

Perhatikan bahwa bahasa tersebut pada dasarnya memetakan ke penerjemah Brainfuck IO-kurang, di mana F_5diperlukan untuk dapat melakukan segala jenis loop yang tepat.

Namun berdasarkan dugaan prime Fermat hanya ada 5 prima Fermat ( F_0- F_4). Jika F_5ada bahasanya adalah Turing-complete, seperti yang kita tahu bahwa Brainfuck adalah Turing-complete. Namun, tanpa F_5Anda tidak akan dapat melakukan percabangan atau pengulangan, pada dasarnya mengunci Anda menjadi program yang sangat sederhana.

Penerapan

(diuji dengan 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

Contoh:

Ini akan menulis H(kependekan dari Hello World!) ke layar dengan baris baru:

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

Simpan sebagai example.fermatdan jalankan seperti ini (catatan: Anda selalu harus memiliki input):

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

Contoh berikut ini akan melakukan cypher gaya Caesar sederhana dengan menambah setiap nilai input dengan satu. Anda jelas harus mengganti ?dengan prime 5 Fermat:

17 65537 5 17 ? 257

Anda dapat mencobanya yang berfungsi dengan mengaktifkan mode cheat dan menggunakan 2 4 1 2 5 3sebagai kode sumber:

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

Menelan dg Kelapa v2

Karena versi sebelumnya memiliki kesalahan yang membuatnya tidak valid untuk kontes ini, dan saya tidak ingin mendapatkan upvotes dari jumlah versi sebelumnya untuk versi ini yang sangat berbeda, versi ini sedang dikirim sebagai posting baru.

Bahasa ini bukan Turing yang lengkap jika Dugaan Collatz dapat dibuktikan untuk semua bilangan bulat positif. Kalau tidak, bahasa Turing lengkap.

Bahasa ini didasarkan dari Kardinal .

Pertama, contVal program dihitung menggunakan rumus
contVal = jumlah (jumlah (nilai ASCII dari baris) * 2 ^ (nomor baris-1))

Selanjutnya, 2 Swallows menuju arah yang berlawanan dibuat pada setiap A atau E dan semua pernyataan belokan bersyarat diatur untuk menunggu inisialisasi.
Menelan yang dibuat di E mengarah ke kiri / kanan dan menelan yang dibuat di A mengarah ke atas / bawah.

Akhirnya, kode akan melakukan langkah-langkah sampai semua pointer telah dihapus atau contVal telah jatuh ke satu.

Pada setiap langkah, jika contVal% 2 == 0 itu akan dibagi 2, jika tidak, itu akan dikalikan tiga dan bertambah satu.

Perintah:

0: atur nilai ke 0
+: nilai kenaikan sebesar 1
>: ubah arah ke kanan
v: ubah arah ke bawah
<: ubah arah ke kiri
^: ubah arah ke atas
R: Pointer berikutnya setelah pointer pertama bandingkan dengan nilai dari pointer pertama. Jika sama, lurus, kalau tidak belok kanan.
L: Pointer berikutnya setelah pointer pertama membandingkan dengan nilai pointer pertama. Jika sama, lurus, kalau tidak belok kiri.
E: Gandakan pointer tetapi menuju ke arah kiri dan kanan
A: Gandakan pointer tetapi menuju ke arah atas dan ke bawah
? : Hapus pointer jika nilainya 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>

Penjelasan:

Jika Dugaan Collatz dapat dibuktikan untuk semua bilangan bulat positif, durasi dari setiap program yang dijalankan dalam bahasa ini terbatas, karena contVal akan selalu konvergen ke 1, sehingga mengakhiri program.

Kalau tidak, saya hanya perlu membuktikan bahwa bahasa ini dapat menerapkan fungsi - fungsi berikut

Peningkatan: yang diwakili oleh +
Constant 0: yang diwakili oleh 0
Akses variabel: variabel disimpan sebagai pointer saat mereka melakukan perjalanan
Rangkaian pernyataan: dengan mengubah jarak yang ditempuh ke operasi, urutan pengoperasian yang dilakukan dapat diubah
Untuk loop: Dalam bahasa ini

E   > V
    ^+R
      +
      A

akan bertindak sebagai for for> count hingga 1 (kode lebih lanjut dapat ditambahkan ke loop)

Begitu pula kodenya

Rv
^<

Akan bertindak sebagai do sampai sama dengan nilai kondisional yang ditetapkan dalam loop R.

Kesempurnaan / Ketidaksempurnaan

Wah, itu menyenangkan.

Kesempurnaan / Ketidaksempurnaan hanya lengkap jika ada angka sempurna yang tak terbatas. Jika ada, itu disebut Kesempurnaan, dan jika tidak ada, itu disebut Ketidaksempurnaan. Sampai misteri ini terpecahkan, ia memegang kedua nama.

Angka sempurna adalah angka yang jumlah pembagi-nya sama dengan angka, jadi enam adalah angka sempurna karena 1+2+3=6.

Kesempurnaan / Ketidaksempurnaan memiliki fungsi-fungsi berikut:

Kesempurnaan / Ketidaksempurnaan berbasis tumpukan, dengan tumpukan yang diindeks nol.

Perintah:

p(x, y): mendorong x ke tumpukan di posisi y.

z(x, y): mendorong x ke tumpukan di posisi y, menghilangkan apa yang sebelumnya di posisi ke-y

r(x): menghapus item xth dari stack

k(x): mengembalikan item ke-X di tumpukan

a(x, y): menambahkan x dan y. Ketika digunakan dengan string, itu menempatkan mereka bersama-sama dalam urutan xy.

s(x, y): kurangi y dari x. dengan string, menghapus len (y) terakhir dari x

m(x, y): mengalikan x dan y. Jika digunakan dengan string, gandakan x kali len y.

d(x, y): membagi x dengan y

o(x): cetakan x

i(x, y): jika x bernilai true, maka ia menjalankan fungsi y

n(): mengembalikan penghitung blok kode sedang dipanggil.

q(): mengembalikan panjang tumpukan

t(): input pengguna

e(x, y): Jika x adalah bilangan bulat, jika x dan y memiliki nilai yang sama, maka ini mengembalikan 1. jika y adalah string maka ia mendapatkan panjang y. jika x adalah sebuah string, maka itu mengkonversi y menjadi sebuah string dan memeriksa apakah mereka sama, dan jika mereka, mengembalikan 1. Jika tidak maka mengembalikan 0.

l(x, y): jika x lebih besar dari y, maka mengembalikan 1. Jika ada string, maka ia menggunakan panjang string.

b(): menghentikan program.

c(x, y): menjalankan x, lalu y.

Untuk mendapatkan yang setara dengan Python and, kalikan dua nilai bersama. Untuk or, tambahkan nilainya, dan untuk not, kurangi nilainya dari 1. Ini hanya berfungsi jika nilainya 1 atau 0, yang dapat dicapai dengan membagi angka dengan sendirinya.

Tipe data: bilangan bulat dan string. String dilambangkan dengan '', dan semua angka non-integer dibulatkan.

Sintaksis:

Kode terdiri dari fungsi bersarang dalam sepuluh {}detik. Sebagai contoh, sebuah program yang akan mendapatkan masukan dan mencetaknya menambahkan akan: {o(a(t(), t()))}. Di latar belakang program ada penghitung yang dimulai pada 0 dan berlanjut dengan 1 setiap kali mengeksekusi blok kode. Blok kode pertama berjalan pada 0, dan seterusnya. Setelah sepuluh blok kode dieksekusi, yang keenam dieksekusi setiap kali penghitung mencapai angka sempurna. Anda tidak perlu memiliki semua sepuluh blok kode untuk program untuk bekerja, tetapi Anda perlu 7 jika Anda ingin membuat loop. Untuk lebih memahami bagaimana bahasa ini bekerja, menjalankan program berikut, yang mencetak meja setiap kali counter mencapai angka sempurna: {}{}{}{}{}{}{o(n())}.

Penerjemah dapat ditemukan di sini: repl.it/GL7S/37 . Pilih 1 dan ketik kode Anda di terminal, atau rekatkan kode Anda di code.perfecttab dan pilih 2 saat Anda menjalankan. Ini akan masuk akal ketika Anda mencobanya.

Bukti kelengkapan Turing / kurangnya kelengkapan Turing.

Menurut artikel pertukaran tumpukan rekayasa perangkat lunak ini , Turing yang lengkap harus dapat memiliki bentuk pengulangan lompatan bersyarat, dan memiliki cara untuk membaca atau menulis memori. Ia dapat membaca / menulis memori dalam bentuk stack, dan itu dapat berulang karena fakta bahwa blok kode ke-6 dieksekusi setiap kali penghitung mencapai angka sempurna. Jika ada angka sempurna dalam jumlah tak terbatas, ia dapat berulang tanpa batas dan Turing lengkap, dan sebaliknya tidak.

Penerjemah Self Bitwise Cyclic Tag yang mengambil 5 karakter, 1 atau 0, sebagai input:

{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)))))}

Dapat diperluas untuk mengambil sejumlah karakter sebagai input. Itu bisa mengambil input yang tak terbatas, tetapi hanya jika ada angka sempurna yang tak terbatas!

Sol

Bahasa pemrograman ini Turing lengkap jika dugaan Scholz benar.

Saya menulis bahasa ini karena @SztupY mengatakan bahwa tidak akan ada hasil yang bergantung pada dugaan untuk menjadi Turing yang lengkap

Daftar Perintah

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

Dengan perintah ini, bahasa ini dapat mensimulasikan mesin Minsky

Penerjemah

Saya akan sangat menyarankan tidak menjalankan ini. Ini menggunakan metode yang sangat lambat untuk memeriksa rantai penjumlahan.

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>

Turing kelengkapan

Bahasa ini menggunakan penghitung untuk sejumlah perintah yang dijalankan yang mengecek dugaan Scholz untuk memodifikasi kelengkapan turing bahasa.

Jika dugaan Scholz benar, program ini bekerja persis seperti mesin Minsky normal dengan
Increment
Decrement
Jump jika Zero
Stop

Namun, jika dugaan Scholz salah, penghitung akhirnya akan mencapai nilai yang dugaan Scholz tidak berlaku. Karena bahasa telah dirancang untuk keluar setelah mencapai angka yang dugaan Scholz salah, program akan keluar setiap kali setelah menjalankan banyak perintah. Oleh karena itu, semua program akan memiliki panjang yang terbatas. Karena ini tidak setuju dengan persyaratan agar bahasa Turing lengkap,

"Kaset tidak dapat diperbaiki panjangnya, karena itu tidak akan sesuai dengan definisi yang diberikan dan akan secara serius membatasi rentang perhitungan yang dapat dilakukan mesin untuk orang-orang dari otomat terikat linear",

bahasa tidak akan menjadi Turing lengkap jika dugaan Scholz salah

Bertunangan

Bertunangan Github .

Readme dan spesifikasinya ada di github, di bawah "README.txt".

Secara umum, program bertunangan terdiri dari pasangan garis, yang panjangnya adalah pasangan prima kembar atau pasangan bertunangan (tidak ada duplikat dapat terjadi). Program ini dijalankan dengan menemukan "himpunan bagian yang lentur" dari baris pertama pada pasangan di dalam baris kedua. Jumlah himpunan bagian tersebut, dikombinasikan dengan jarak levenshtein antara baris kedua asli dan baris kedua tanpa himpunan bagian yang lentur, menentukan perintah untuk mengeksekusi.

Saya akan mengutip bukti untuk posting ini:

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.

Paritas yang damai

Bahasa ini didasarkan pada apakah ada angka persahabatan dengan paritas yang berlawanan .

Perintah

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.  

Mengontrol aliran

Program berputar berulang kali dari kiri ke kanan sebelum kembali ke awal. Jika menemukan "j", ia memeriksa nilai untuk menentukan apakah harus mengubah baris. Jika nomor tersebut adalah angka damai dengan paritas yang berlawanan dengan pasangannya, maka turun satu baris (berputar kembali ke atas), Jika tidak, jika nomor tersebut adalah angka damai, maka naik satu baris jika belum berada di baris atas.

Program hanya dapat berakhir jika program mencapai x pada baris apa pun di luar baris atas.

Turing Kelengkapan

Program ini dapat digunakan untuk mensimulasikan mesin Minsky dengan asumsi bahwa ada sepasang nomor yang bersahabat dengan paritas yang berlawanan.

j, {dan} dapat digunakan untuk mensimulasikan JZ (r, x) meskipun ia akan memeriksa angka damai sebagai lawan dari nol.
+ adalah INC (r)
- adalah DEC (r)
x adalah HALT

Jika Anda tidak dapat meninggalkan baris pertama, perintah x dan} tidak melakukan apa pun. Hal ini menyebabkan program tidak dapat memasuki kondisi HALT kecuali jika itu adalah program kosong. Oleh karena itu, di bawah uraian bahwa kelengkapan Turing memerlukan status HALT , bahasanya akan menjadi tidak lengkap.

Penerjemah

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>

Garis baru

Penafian: Agak berantakan dan cukup sederhana. Ini adalah bahasa pertama yang pernah saya tulis dan dugaan adalah satu-satunya yang saya mengerti. Saya tahu pengguna lain memiliki jawaban yang lebih panjang dengan jawaban yang sama tetapi saya memutuskan untuk tetap menulis ini.

Untuk menulis di Newline, Anda harus memiliki banyak waktu dan baris baru ( \n). Ini berhasil karena dugaan Legendre benar. Setiap operator harus jatuh pada angka dalam dugaan Legendre yang kita mulai dengan n = 1. Setiap kali Anda memiliki operator, Anda mengambil jumlah \ n dan memasukkannya ke dalam dugaan Legendre dan mendapatkan kisaran yang jumlah prima berikutnya dari \ n harus masuk. Jadi untuk memulai Anda lakukan \n\nmaka Anda pindah ke operator lalu ke operator \nlain kita berada di 3 baris baru. Sekarang yang berikutnya adalah 5 sehingga Anda menambahkan \n\ndan pada operator memastikan bahwa garis operator terakhir memiliki jumlah baris baru yang tepat sehingga Anda berada pada jumlah prima yang termasuk dalam dugaan Legendre yang kami mulai.

Bilangan (array) seperti variabel. Setiap kali seorang operator berjalan (yang menggunakan angka) akan bertambah.

+ 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

Selama kami memiliki bilangan prima tak terbatas yang mengikuti aturan, bahasa ini memiliki rekaman yang tidak terbatas.

Mesin Minsky

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

Bagaimana itu bekerja:

\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

Cobalah di KhanAcademy .

Taggis

Taggis adalah bahasa berdasarkan sistem tag .

Kelengkapan turing Taggis didasarkan pada dugaan Collatz

Sintaksis

Sintaksis program Taggis hanyalah tiga string (aturan produksi) yang seluruhnya terdiri dari huruf a, b, dan c, dipisahkan oleh spasi.

Eksekusi

Satu-satunya status program Taggis adalah string yang terdiri dari tiga karakter yang sama.

Taggis mengimplementasikan sistem tag TS (3, 2), di mana dalam setiap langkah 2 huruf pertama dari "tag" saat ini dihapus, dan huruf pertama yang ada di bagian yang dihapus tersebut akan mendapatkan aturan produksi yang sesuai ditambahkan pada akhir string.

Sebagai contoh, program Taggis bc a aaamengimplementasikan masalah 3n + 1, di mana iterasi diwakili oleh jumlah as yang sesuai dan langkah 3n + 1 diganti dengan (3n + 1) / 2 [1], yang mengarah ke output program:

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

Turing kelengkapan

Tentu saja, sistem sederhana ini mungkin tampak terlalu sederhana untuk meniru kelengkapan Turing, tetapi ternyata setiap mesin Turing dengan 2 simbol (kelas yang mencakup mesin universal) dapat dikonversi ke sistem tag dengan 2 karakter yang dihapus dari kepala, dan aturan produksi 32 * m, di mana mjumlah negara bagian dalam mesin Turing.

Mesin Turing universal terkecil yang diketahui dengan hanya 2 simbol menggunakan 18 negara dan dengan demikian sistem tag yang sesuai berisi aturan produksi 576 kekalahan [2].

Namun, kelas komputasi dari himpunan semua sistem tag dengan 3 produksi dan 2 simbol yang dihapus terkait dengan Collatz Conjecture [2]. Jika dugaan Collatz terbukti salah, maka Taggis adalah Turing-complete. Jika tidak, ini didasarkan pada masalah LAIN yang belum terpecahkan dalam matematika, menemukan mesin Turing yang lebih kecil daripada

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. yang setara dengan fungsi Collatz asli sebagai 3n + 1 dari yang aneh nakan selalu genap dan oleh karena itu pembagian dapat diterapkan secara otomatis

2. Sistem tag dan fungsi seperti Collatz, Liesbeth De Mol ,