Wie kann ein zyklisches Tag-System mit einer Ausgabe anhalten?

Zum Beispiel können wir sagen, dass wir ein abstraktes Programm haben, das bei einer endlichen binären Zeichenfolge als Eingabe alle Nullen entfernt (dh 0010001101011 ergibt 111111), was definitiv eine Turing-berechenbare Funktion ist.

Wie kann ein zyklisches Tag-System dies berechnen (was es per Definition als Turing-vollständig definieren kann), wenn es nur anhält, wenn es die leere Zeichenfolge erreicht? Der Wikipedia-Artikel enthält ein Beispiel für die Konvertierung in ein 2-Tag-System, fügt jedoch einen emulierten Halt hinzu, den das ursprüngliche System nicht hat.

Ich kann keinen Hinweis darauf finden, wie ein zyklisches Tag-System sinnvoll anhält. Was soll seine Ausgabe sein? Ich habe über Dinge wie nachgedacht

• Anzahl der Schritte (aber dann schränkt die Eingabe die mögliche Ausgabe ohne eine ausgefallene Codierung ein, die ich nicht finden kann)
• Die letzte Produktion (aber das hat nur einen endlichen Leistungsbereich)
• Fixpunkte (die in diesem System nicht erkannt werden können und nur mit sehr begrenzten Produktionsregeln und Eingaben existieren)

aber sie funktionieren nicht, zumindest nicht in irgendeiner Weise, die ich sehen kann.

Neary and Woods beschreiben eine effiziente Simulation von Turing-Maschinen mit zyklischen Tag-Systemen, die die Arbeit von Matthew Cook verbessern . Die Vollständigkeit der Turing ist ein etwas fließender und informeller Begriff. Ein Computersystem X simuliert ein anderes Computersystem Y, wenn für jedes Programm in Y ein Programm in X erstellt werden kann, so dass wir beim Betrachten des Transkripts des X-Programms ein Transkript des Y-Programms wiederherstellen können.

In den obigen Abhandlungen können Sie nachlesen, was dies für zyklische Tag-Systeme bedeutet. Die Grundidee ist, dass, wenn die Turing-Maschine anhält, die zyklischen Tag-Systeme weiterlaufen und für immer dieselbe Konfigurationssequenz wiederholen, die die Haltekonfiguration der Turing-Maschine darstellt. In diesem Sinne kann es tatsächlich Funktionen berechnen.

In einer früheren Antwort habe ich festgestellt, dass einige Rechenmodelle nur Entscheidungsprobleme berechnen können, in dem Sinne, dass sie entweder nicht anhalten oder mit nur einem Bit Ausgabe anhalten. In diesem Fall können Sie die allgemeine Funktion auf mindestens zwei Arten codieren:

1. Betrachten Sie bei gegebener Funktion die Sprache der Paare .⟨ x , f ( x ) $f$$\langle x,f(x) \rangle$

2. Betrachten Sie bei gegebener Funktion die Sprache der Tripel so, dass das te Bit von (falls vorhanden) gleich .⟨ x , i , b ⟩ i f ( x ) $f$$\langle x,i,b \rangle$$i$$f(x)$$b$

Wie immer müssen die Maschinen immer anhalten.

Obwohl nicht anhaltende Versionen des zyklischen Tags für zellulare Automaten von besonderem Interesse sein können, kann ein zyklisches Tag-System auch so konzipiert werden, dass eine universelle Turing-Maschine so simuliert wird, dass sie anhält, wenn das TM anhält, und ein Ausgabewort anzeigt , das das codiert Maschinenausgabe:

1. Simulieren Sie das TM mit einem 2-Tag-System, das alle augenblicklichen Konfigurationen des TM codiert, und verwenden Sie ein separates "Ausgabealphabet", um jede Haltekonfiguration zu codieren, sodass das Tag-System anhält (indem Sie dieses Wort Buchstabe für Buchstabe löschen), wenn TM hält an. ( Dieses Papier zeigt im Detail, wie dies mit einer Wang-Maschinenformulierung von TMs erreicht werden kann.)

2. Simulieren Sie das 2-Tag-System mit einem zyklischen Tag-System, wie im Abschnitt über das zyklische Tag-System des Wikipedia-Artikels beschrieben . Da jeder Buchstabe im 2-Tag-Ausgabealphabet eine leere Zeichenfolge als Anhang hat (wodurch die 2-Tag-Simulation angehalten wird), hat das zyklische Tag-System das gleiche Anhalte- / Ausgabeverhalten.

$\{\alpha_i\}$$\alpha_i\rightarrow \epsilon$

$\{0,1\}$

$0$$101$$11$-

2-Tag

input alphabet {a,b}, output alphabet {c}
input encoding:
<0> = aa
<1> = bb
input = <101> = bbaabb
output decoding: <cc> = 1

Produktionen:

a -> - 
b -> cc 
c -> - 

Berechnung:

bbaabb   <-- input word <101>
  aabbcc
    bbcc
      cccc  <-- output word <11>
        cc
         -

zyklisches Tag

Codierung des 2-Tag-Alphabets:

<a> = 100
<b> = 010
<c> = 001
cyclic tag system = [-,001001,-,-,-,-]
cyclic tag input = <bbaabb> = 010010100100010010 

Berechnung:

appendant    dataword
---------    ---------------------------------------------------------------
-            010010100100010010  <-- input word <bbaabb> = <<101>>
001001        10010100100010010
-              0010100100010010001001
-               010100100010010001001
-                10100100010010001001
-                 0100100010010001001
-                  100100010010001001
001001              00100010010001001
-                    0100010010001001
-                     100010010001001
-                      00010010001001
-                       0010010001001
-                        010010001001
001001                    10010001001
-                          0010001001001001
-                           010001001001001
-                            10001001001001
-                             0001001001001
-                              001001001001  <-- output word <cccc> = <<11>>
001001                          01001001001
-                                1001001001
-                                 001001001
-                                  01001001
-                                   1001001
-                                    001001
001001                                01001
-                                      1001
-                                       001
-                                        01
-                                         1
-                                         -