Conjetura sobre dos contadores de autómatas

Me gustaría probar (o refutar) la siguiente conjetura:

Conjetura : un autómata de dos contadores (2CA) no puede decidir el siguiente idioma:

$L = \{ n \mid$ the ternary y las representaciones binarias de tienen longitud par o longitud impar$n$$\}$

Un 2CA puede verificar fácilmente si la representación binaria tiene una longitud par o impar (solo siga dividiendo entre dos y actualice un indicador de "longitud par" después de cada división); de la misma manera, puede verificar si la representación ternaria tiene una longitud par o impar (solo siga dividiendo por tres y actualice un indicador de "longitud par" después de cada división).

Pero para calcular uno de ellos debe destruir su entrada y no puede recuperarlo para calcular el otro; por lo que parece que no hay manera de decidir .$L$

¿Conoces una técnica que pueda usarse para probar la conjetura?
¿O puedes refutar la conjetura construyendo un 2CA que decide ? $L$

Intenté el mismo enfoque seguido por Ibarra para demostrar que un 2CA no puede decidir$\{n^2\mid n \geq 1\}$ , pero no parece la forma correcta.

Nota : por simplicidad, un 2CA es equivalente a un programa con una variable que inicialmente contiene la entrada y el siguiente conjunto de instrucciones:$c$

• INC : agrega uno a la variable;
• DEC : decremento (solo si es mayor que cero);$c$
• JZ $lab$ c l a b : si es cero, salte al etiquetas ; de lo contrario, continúe;$c$$lab$
• MUL$K$ c K : multiplique por el costante ;$c$$K$
• DIV$K [, lab_0, lab_1,...,lab_{K-1}]$ : divide entre la constante y almacena el cociente en ( ); posiblemente salte a diferentes etiquetas de acuerdo con el resto ( );$c$$K$$c$$c = \lfloor c / K \rfloor$$c \bmod K$
• Laboratorio GOTO$lab$ : salto incondicional;
• HALT Aceptar | Rechazar : detener y aceptar o detener y rechazar.

Por ejemplo, un programa para verificar si la representación binaria de $n$ tiene una longitud par es:

   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

(podemos construir un equivalente 2CA)

Por eso, la gente sigue insistiéndome para que publique esto aunque solo resuelva una versión simplificada del problema. Bien entonces :)

Al final de esto, pondré algo de lo que aprendí del artículo de Ibarra y Trân, y por qué ese método se descompone en nuestro problema general, pero tal vez aún brinde información útil.

Pero primero, veremos el problema más simple de tratar de decidir el conjunto

2 n$L = \{ 2^n \mid$ las representaciones ternarias y binarias de tienen longitud par o longitud impar$2^n$$\}$

Observe cómo esto tiene lugar de como en el problema original. En particular, si el número de entrada no es una potencia de 2, queremos rechazarlo en lugar de intentar calcular su longitud en cualquier base.$2^n$$n$

Esto simplifica enormemente las cosas: si el número original se escribe primo factorizado como , entonces para todos los excepto solo necesitamos verificar que todos son .$2^{v_2} 3^{v_3} 5^{v_5} 7^{v_7} ...$$v_i$$v_2$$0$

Esto nos permite resolver este problema simplificado mediante el uso de una envoltura alrededor del método anterior (supongo por Minsky) de codificar el estado de un autómata counter en los exponentes de la factorización prima de la variable única de un autómata de multiplicación / división, que, como se señaló en el OP anterior, es más o menos equivalente a un autómata de 2 contadores.$k$

Primero, necesitamos un autómata counter para envolver. Utilizaremos 3 contadores, llamados , y .$k$$v_2$$v_3$$v_5$

El autómata aceptará iff para los valores iniciales del contador, las representaciones ternarias y binarias de tienen longitud par o longitud impar, y tanto como son cero. Cuando acepta, primero pondrá a cero todos sus contadores.$2^{v_2}$$v_3$$v_5$

Aquí hay un código para eso, en un formato de ensamblaje similar al OP (acabo de agregar variables a las instrucciones). Realmente no lo he probado, ya que no tengo nada para ejecutarlo, pero considero que esto es una formalidad: se sabe que los autómatas de 3 contadores son completos de Turing y son capaces de construir cualquier función computable de uno de sus valores iniciales.

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

El siguiente paso es volver a codificar lo anterior en los exponentes de un único autómata variable. Como el resultado es bastante largo, solo describiré el método general, pero hay una versión completa (ligeramente "optimizada" en algunos sitios) en mi sitio web.

                JZ vp, label
                DEC vp
next:           ...

se convierte (básicamente dividir entre p, y luego hacer la limpieza para deshacer si la división no fue uniforme):

                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 vpse convierte MUL p. Individual JZy DECprimero se puede cambiar a la forma combinada. GOTO labely no HALT Rejecthan cambiado

HALT Acceptno cambiaría, excepto que en nuestro caso todavía tenemos que hacer una verificación final: debemos asegurarnos de que no haya factores primos en el número que no sean 2,3 y 5. Dado que nuestro autómata de 3 contadores pone a cero los contadores usa cuando acepta, esto es simple: solo pruebe que la variable final sea 1, lo que puede hacerse saltando al código

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

El código en mi sitio web también tiene una comprobación inicial de que el número no es cero, lo que acabo de dar cuenta es redundante con las comprobaciones v3, v5 cero, bueno.

Como mencioné, el método anterior funciona para el problema simplificado, pero realmente no tiene posibilidades de funcionar para el problema general, porque: En el problema general, el valor preciso del exponente de cada primo cuenta para decidir su tamaño general y, por lo tanto, qué longitud tiene. Tiene en varias bases. Esto significa que:

• No tenemos primos "gratuitos" para usar en los contadores.
• Incluso si nos hizo tener primos gratuitas para contadores, que en realidad no tenemos una manera de extraer toda la información necesaria de los infinitamente muchos otros primos cuyos valores exponente hacer la materia.

Así que terminemos con una explicación de la esencia del método general del documento vinculado anterior por Ibarra y Trân ( versión de descarga gratuita ) sobre cómo demostrar que ciertos problemas no se pueden resolver con un 2CA, y cómo se descompone molestamente en nuestro caso.

Primero, modifican cada 2CA en una "forma normal", en la cual los dos contadores cambian en "fases" entre una que aumenta y la otra que disminuye hasta que llega a cero. El número de estados de autómata normalizado juega un papel importante en las estimaciones.$s$

Luego, analizan este autómata para concluir que pueden construir ciertas secuencias aritméticas de números cuyo comportamiento está vinculado. Para ser precisos (algo de esto no se establece como teorema, pero está implícito en la prueba de sus dos ejemplos principales):

1. Si un número x es aceptada por el autómata, sin el tamaño del contador distinto de cero al comienzo de una fase nunca va , entonces existe un entero tal que todos los números , son aceptados.$v^x_i$$i$ $\leq s$$D>0$$x + n D$$n\geq 0$

2. Si un conjunto contiene al menos números aceptados de tal manera que para cada número haya una fase tal que , entonces podemos encontrar y enteros tal que$X$$s^2+1$$x\in X$$i$$v^x_i\leq s$$p, r\in X$$K_1,K_2$

   • Para cada entero , ya sea y Se aceptan por el autómata, o ambos son rechazados.$n\geq 0$$p + n K_1$$r + n K_2$

(Pensamientos:

• Requieren para pero creo que esto es realmente innecesario. En realidad también es que son aceptados.$x>s$$x\in X$
• La mayor parte de esto también debería ser válido para los números rechazados , siempre que el rechazo sea por detención explícita en lugar de no terminación).

Para sus propios ejemplos, también usan con frecuencia el hecho de que no tienen factores primos . Para demostrar la imposibilidad, derivan contradicciones al demostrar que tales secuencias aritméticas no pueden existir.$D,K_1,K_2$$>s$

En nuestro problema, obtener una contradicción de esto se rompe con el segundo caso. Si tenemos , donde es lo suficientemente grande como para que ningún número entre y sea ​​divisible por o , entonces tampoco habrá potencias de 2 o 3 entre y , por lo que ambos son aceptados o ambos rechazados. k p r 2 k 3 k p + 6 k n q + 6 k$K_1 = K_2 = 6^k$$k$$p$$r$$2^k$$3^k$$p + 6^k n$$q + 6^k n$

Todavía se puede demostrar que el punto 1 es imposible, porque los poderes de 2 y 3 en su mayoría crecen cada vez más. Y creo que puedo mostrar el segundo caso imposible si (he enviado un correo electrónico a @MarzioDeBiasi con el argumento). Entonces, tal vez alguien podría usar esta información para restringir aún más la forma del autómata, y finalmente derivar una contradicción de eso.$K_1\neq K_2$