Congettura su due contatori automi

Vorrei provare (o confutare) la seguente congettura:

Congettura : un automa a due contatori (2CA) non può decidere la seguente lingua:

le rappresentazioni ternarie e binarie di hanno lunghezza pari o dispari $L = \{ n \mid$ $n$ $\}$

Un 2CA può facilmente verificare se la rappresentazione binaria ha una lunghezza pari o dispari (basta continuare a dividere per due e aggiornare un flag "lunghezza pari" dopo ogni divisione); allo stesso modo può verificare se la rappresentazione ternaria ha lunghezza pari o dispari (basta continuare a dividere per tre e aggiornare un flag "lunghezza pari" dopo ogni divisione).

Ma per calcolarne uno deve distruggere il suo input e non può recuperarlo per calcolare l'altro; così sembra che non v'è alcun modo di decidere . $L$

Conosci una tecnica che può essere utilizzata per provare la congettura?
Oppure puoi confutare la congettura costruendo un 2CA che decide ? $L$

Ho provato lo stesso approccio seguito da Ibarra per dimostrare che un 2CA non può decidere $\{n^2\mid n \geq 1\}$ , ma non sembra nel modo giusto.

Nota : per semplicità un 2CA equivale a un programma con una variabile che inizialmente contiene l'input e il seguente set di istruzioni: $c$

INC : aggiungine uno alla variabile;
DEC : decrementa (solo se è maggiore di zero); $c$
JZ $lab$ : se è zero, saltare all'etichetta altrimenti continuare; $c$ $lab$
MUL $K$ : moltiplicare per il costante ; $c$ $K$
DIV $K [, lab_0, lab_1,...,lab_{K-1}]$ : dividere per la costante e memorizzare il quoziente in ( ); eventualmente saltare a etichette diverse in base al resto ( ); $c$ $K$ $c$ $c = \lfloor c / K \rfloor$ $c \bmod K$
GOTO $lab$ : salto incondizionato;
HALT Accept | Rifiuta : ferma e accetta o ferma e rifiuta.

Ad esempio un programma per verificare se la rappresentazione binaria di ha lunghezza pari è: $n$

   loop: JZ even   // test if n = 0
         DIV 2
         JZ odd    // test if n = 0
         DIV 2
         GOTO loop
   even: HALT Accept
    odd: HALT Reject

(possiamo costruire un 2CA equivalente)

automata-theory

— Marzio De Biasi
fonte

Non so come vanno le prove di impossibilità, ma il caso {

∣ la rappresentazione ternaria di

ha una lunghezza dispari} è risolvibile, perché ogni volta che il tuo input ha conosciuto solo fattori primi puoi trattare i tuoi esponenti (n qui) come contatori in un automa simulato con tutti i contatori (simulati da numeri primi aggiuntivi) che desideri, quindi Turing-complete.

2^{n}

$2^n$

2^{n}

$2^n$

— Ørjan Johansen,

Ti ho inviato un "codice" via e-mail e l'ho anche messo sul mio sito Web nel caso in cui qualcun altro lo stia guardando.

— Ørjan Johansen,

@joro Il metodo che ho descritto ha una rigorosa limitazione: può gestire solo finitamente molti fattori primi dell'input (tranne che per i test se il resto è tutto 0 o no). Il problema è che nel problema generale, gli esponenti di tutti i primi i fattori contano. Puoi effettivamente calcolare la tua

o la tua

fino alla parità, ma per quanto ne so, non c'è modo di confrontare un input generale con

senza distruggerlo nel processo, in modo da non poter testare l' altro uno dopo. La mia impressione ora è che il problema generale non sia risolvibile con un 2CA.

k

$k$

m

$m$

2^{k}

$2^k$

3^{m}

$3^m$

— Ørjan Johansen

@ ØrjanJohansen: sono d'accordo con vzn: se vuoi, puoi pubblicare la risposta con la soluzione al problema più semplice limitato (vale la pena :-) e può essere di aiuto a coloro che vogliono entrare rapidamente nel problema originale). Puoi anche MOLTO notare brevemente perché l'approccio di Ibarra fallisce per il problema generale e perché la soluzione della versione più semplice fallisce per quella generale (copia-incolla il commento su joro).

— Marzio De Biasi,

grazie! fantastico / raro vedere tutto l'interesse / attività in questo problema. qualche altro commento / domanda su questo problema

— vzn

Quindi la gente continua a tormentarmi per pubblicarlo, anche se risolve solo una versione semplificata del problema. Va bene allora :)

Alla fine, inserirò parte di ciò che ho appreso dall'articolo di Ibarra e Trân, e perché questo metodo si rompe sul nostro problema generale, ma forse fornisce ancora alcune informazioni utili.

Ma prima vedremo il problema più semplice di provare a decidere il set

le rappresentazioni ternarie e binarie di hanno lunghezza pari o dispari $L = \{ 2^n \mid$ $2^n$ $\}$

$2^n$ $n$

$2^{v_2} 3^{v_3} 5^{v_5} 7^{v_7} ...$ $v_i$ $v_2$ $0$

$k$

$k$ $v_2$ $v_3$ $v_5$

$2^{v_2}$ $v_3$ $v_5$

Ecco un po 'di codice per questo, in un formato assembly simile all'OP (ho appena aggiunto variabili alle istruzioni). In realtà non l'ho testato, dal momento che non ho nulla con cui eseguirlo, ma lo considero una formalità: gli automi a 3 contatori sono ben noti per essere completi di Turing e per essere in grado di costruire qualsiasi funzione calcolabile di uno dei loro valori iniziali.

// Check that v3 and v5 are both zero.
                JZ v3, check5
                GOTO reject
check5:         JZ v5, init3
                GOTO reject
// Decrement v2 until it is zero, constructing 2^n in the process.  If 2^n
// was even, we will then pass to even2 with 2^n in v3; If 2^n was odd, we
// will pass to odd2 with 2^n in v5.
init3:          INC v3          // Set v3 to 1 = 2^0 to start with.
even1:          // We have decremented v2 an even number of times so far.
                // 2^decremented amount is in v3.
                JZ v2, odd2
                DEC v2
dup3to5:        JZ v3, odd1
                DEC v3
                INC v5
                INC v5
                GOTO dup3to5
odd1:           // We have decremented v2 an odd number of times so far.
                // 2^decremented amount is in v5.
                JZ v2, even2
                DEC v2
dup5to3:        JZ v5, even1
                DEC v5
                INC v3
                INC v3
                GOTO dup5to3
// The second part checks the ternary length of 2^n, which starts out in v3
// or v5 according to whether the *binary* length of 2^n (i.e. n+1) was odd
// or even.
odd2:           // v3 needs to have odd ternary length to accept.
                // It is simplest to consider 0 to have even length in both
                // binary and ternary.  This works out as long as we're
                // consistent.
                JZ v3, reject
trisect3to5:    DEC v3
                DEC v3
                JZ v3, even2
                DEC v3
                INC v5
                GOTO trisect3to5
even2:          // v5 needs to have even ternary length to accept
                JZ v5, accept
trisect5to3:    DEC v5
                DEC v5
                JZ v5, odd2
                DEC v5
                INC v3
                GOTO trisect5to3
accept:         HALT Accept
reject:         HALT Reject

Il passo successivo è quindi ricodificare quanto sopra negli esponenti di un singolo automa variabile. Dato che il risultato è piuttosto lungo, descriverò solo il metodo generale, ma una versione completa (leggermente "ottimizzata" in punti) è sul mio sito web.

                JZ vp, label
                DEC vp
next:           ...

diventa (sostanzialmente dividi per p, quindi esegui la pulizia per annullare se la divisione non era pari):

                DIV p, next, ..., newlabel.fp-1
newlabel.f1:    MUL p
                GOTO newlabel.i1
...
newlabel.fp-1:  MUL p
                INC
newlabel.ip-2:  INC
...
newlabel.i1:    INC
                GOTO label
next:           ...

INC vpdiventa MUL p. Individuale JZe DECpuò essere prima modificato nella forma combinata. GOTO labele HALT Rejectsono invariati.

HALT Acceptrimarrebbe invariato, tranne che nel nostro caso abbiamo ancora un controllo finale da fare: dobbiamo assicurarci che non ci siano fattori primi nel numero diversi da 2,3 e 5. Dal momento che il nostro particolare automa a 3 contatori zeri i contatori esso utilizza quando accetta, questo è semplice: basta provare che la variabile finale è 1, che può essere fatta saltando al codice

                DEC     // BTW it cannot be zero before this.
                JZ accept
                HALT Reject
accept:         HALT Accept

Il codice sul mio sito web ha anche un controllo iniziale che il numero non è zero, che ho appena realizzato è ridondante con i controlli zero v3, v5, oh bene.

Come ho già detto, il metodo sopra funziona per il problema semplificato, ma in realtà non ha alcuna possibilità di lavorare per quello generale, perché: nel problema generale il valore preciso dell'esponente di ogni numero primo conta per decidere la sua dimensione generale e quindi quale lunghezza ha in varie basi. Ciò significa che:

Non abbiamo numeri primi "liberi" da usare per i contatori.
Anche se abbiamo fatto avere numeri primi gratuiti per i contatori, che in realtà non hanno un modo per estrarre tutte le informazioni necessarie dagli infiniti altri numeri primi i cui valori esponente fare la materia.

Quindi terminiamo con una spiegazione dell'essenza del metodo generale dall'articolo collegato sopra di Ibarra e Trân ( versione scaricabile gratuitamente ) su come dimostrare che alcuni problemi non sono risolvibili da un 2CA e come si rompe fastidiosamente nel nostro Astuccio.

$s$

Quindi, analizzano questo automa per concludere che possono costruire determinate sequenze aritmetiche di numeri il cui comportamento è collegato. Per essere precisi (alcuni di questi non sono indicati come teoremi, ma sono impliciti nella dimostrazione di entrambi i loro due esempi principali):

$v^x_i$ $i$ $\leq s$ $D>0$ $x + n D$ $n\geq 0$
$X$ $s^2+1$ $x\in X$ $i$ $v^x_i\leq s$ $p, r\in X$ $K_1,K_2$
- $n\geq 0$ $p + n K_1$ $r + n K_2$

(Pensieri:

$x>s$ $x\in X$
La maggior parte di questo dovrebbe valere anche per i numeri rifiutati , a condizione che il rifiuto si interrompa esplicitamente anziché non terminando.

$D,K_1,K_2$ $>s$

$K_1 = K_2 = 6^k$ $k$ $p$ $r$ $2^k$ $3^k$ $p + 6^k n$ $q + 6^k n$

$K_1\neq K_2$

— Ørjan Johansen
fonte

Risposta molto buona e chiara!

— Marzio De Biasi,