Come può un sistema di tag ciclico arrestarsi con un output?

Ad esempio, possiamo dire di avere un programma astratto che, data una stringa binaria finita come input, rimuove tutti gli zeri (cioè 0010001101011 restituisce 111111), che è sicuramente una funzione calcolabile di Turing.

Come può un sistema di tag ciclico calcolare questo (che può, per definizione, essendo Turing completo) quando si ferma solo quando raggiunge la stringa vuota? L'articolo di Wikipedia fornisce un esempio di conversione in un sistema a 2 tag, ma aggiunge un arresto emulato che il sistema originale non ha.

Non riesco a trovare alcun riferimento a come un sistema di tag ciclico si arresta in modo significativo. Quale dovrebbe essere il suo output? Ho considerato cose del genere

• Numero di passaggi (ma l'input limita l'output possibile senza un tipo di codifica elaborata che non riesco a trovare)
• L'ultima produzione (ma che ha solo una gamma di output finita)
• Punti fissi (che non possono essere rilevati in questo sistema ed esistono solo con regole e input di produzione molto limitati)

ma non funzionano, almeno non in alcun modo riesco a vedere.

Neary e Woods descrivono un'efficace simulazione delle macchine Turing che utilizzano sistemi di tag ciclici, migliorando il lavoro di Matthew Cook . La completezza di Turing è una nozione piuttosto fluida e informale. Un sistema di elaborazione X simula un altro sistema di elaborazione Y se, dato ciascun programma in Y, possiamo elaborare un programma in X tale che, guardando la trascrizione del programma X, possiamo recuperare una trascrizione del programma Y.

Puoi guardare i documenti sopra per vedere cosa significa questo per i sistemi di tag ciclici. L'idea di base è che quando la macchina di Turing si ferma, i sistemi di tag ciclici continuano a funzionare, ripetendo per sempre la stessa sequenza di configurazioni, che rappresentano la configurazione di arresto della macchina di Turing. In questo senso può effettivamente calcolare le funzioni.

In una risposta precedente ho notato che alcuni modelli di calcolo possono calcolare solo problemi di decisione, nel senso che o non si fermano, o si fermano con un solo bit di output. In tal caso, puoi codificare la funzione generale in almeno due modi:

1. Data una funzione , considera il linguaggio delle coppie .$f$$\langle x,f(x) \rangle$

2. Data una funzione , considera la lingua di triple tale che l' bit di (se presente) sia uguale a .$f$$\langle x,i,b \rangle$$i$$f(x)$$b$

Come al solito, richiediamo che la macchina si fermi sempre .

Sebbene le versioni non-stop del tag ciclico possano essere di particolare interesse per gli automi cellulari, un sistema di tag ciclico può anche essere progettato per simulare una macchina Turing universale in modo tale da arrestarsi se il TM si ferma, visualizzando una parola di output che codifica il uscita della macchina:

1. Simula la TM con un sistema a 2 tag che codifica tutte le configurazioni istantanee della TM, usando un "alfabeto di output" separato per codificare qualsiasi configurazione di arresto, in modo che il sistema di tag si arresti (cancellando questa parola lettera per lettera) se il TM si ferma. ( Questo documento mostra in dettaglio come ciò può essere fatto utilizzando una formulazione di macchine a Wang .)

2. Simula il sistema a 2 tag mediante un sistema di tag ciclico come descritto nella sezione Sistema di tag ciclico dell'articolo di Wikipedia . Poiché ogni lettera dell'alfabeto di output a 2 tag ha una stringa vuota come appendice (causando l'arresto della simulazione a 2 tag), il sistema di tag ciclico avrà lo stesso comportamento di arresto / output.

La chiave di questo approccio è che un alfabeto di output designato, ad esempio , consente a ciascuna delle sue lettere di avere la stringa vuota come appendice ( ), facendo sì che la simulazione cancelli il dataword e battuta d'arresto.$\{\alpha_i\}$$\alpha_i\rightarrow \epsilon$

NB : Per tutti e tre i tipi di sistema (TM, etichetta, tag ciclico), l'identificazione univoca di uscita può essere garantita utilizzando un alfabeto di uscita specificato, e questo può essere fatto sia per arrestare e non di sosta varietà di questi sistemi. (Dato che le TM "standard" sono di tipo bloccante, è ironico che le macchine di calcolo originali di Turing fossero della varietà non-stop con l'alfabeto di output .)$\{0,1\}$

Con lo stesso approccio, possiamo anche costruire direttamente un semplice sistema a 2 tag per cancellare qualsiasi s da una stringa binaria, quindi simularlo con un tag ciclico. I calcoli diventano rapidamente noiosi, quindi lo applicheremo solo alla stringa di input , fermandoci con la stringa di output . (Il simbolo indicherà la stringa vuota.)$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

produzioni:

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

calcolo:

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

tag ciclico

codifica dell'alfabeto a 2 tag:

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

calcolo:

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
-                                         -