Conjectura sobre autômatos de dois contadores

Gostaria de provar (ou refutar) a seguinte conjectura:

Conjectura : um autômato de dois contadores (2CA) não pode decidir o seguinte idioma:

$L = \{ n \mid$ as representações ternárias e binárias de$n$ têm comprimento par ou comprimento ímpar$\}$

Um 2CA pode facilmente verificar se a representação binária tem comprimento par ou ímpar (continue dividindo por dois e atualize um sinalizador "comprimento par" após cada divisão); da mesma maneira, ele pode verificar se a representação ternária tem comprimento par ou ímpar (continue dividindo por três e atualize um sinalizador "comprimento par" após cada divisão).

Mas, para calcular um deles, ele deve destruir sua entrada e não pode recuperá-lo para calcular o outro; por isso parece que não há nenhuma maneira de decidir $L$ .

Você conhece uma técnica que pode ser usada para provar a conjectura?
Ou você pode refutar a conjectura construindo um 2CA que decide $L$ ?

Tentei a mesma abordagem seguida por Ibarra para provar que um 2CA não pode decidir $\{n^2\mid n \geq 1\}$ , mas parece não ser o caminho certo.

Nota : por simplicidade, 2CA é equivalente a um programa com uma variável $c$ que inicialmente contém a entrada e o seguinte conjunto de instruções:

• INC : adicione um à variável;
• DEC : decremento $c$ (somente se for maior que zero);
• JZ $lab$ : se $c$ for zero, salte para rotular $lab$ caso contrário, continue;
• MUL $K$ : multiplique $c$ pelo custo $K$ ;
• $K [, lab_0, lab_1,...,lab_{K-1}]$$c$$K$$c$$c = \lfloor c / K \rfloor$$c \bmod K$
• Laboratório GOTO$lab$ : salto incondicional;
• HALT Aceitar | Rejeitar : parar e aceitar ou parar e rejeitar.

Por exemplo, um programa para verificar se a representação binária de tem tamanho uniforme é:$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

(podemos construir um 2CA equivalente)

Portanto, as pessoas continuam me incomodando a postar isso, mesmo que isso resolva apenas uma versão simplificada do problema. Está bem então :)

No final, vou colocar um pouco do que aprendi no artigo de Ibarra e Trân, e por que esse método se decompõe em nosso problema geral, mas talvez ainda dê algumas informações úteis.

Mas primeiro, veremos o problema mais simples de tentar decidir o conjunto

2 n$L = \{ 2^n \mid$ das representações ternárias e binárias de tem comprimento par ou comprimento ímpar$2^n$$\}$

Observe como isso tem vez de como no problema original. Em particular, se o número de entrada não for uma potência de 2, queremos rejeitá-lo, em vez de tentar calcular seu comprimento em qualquer base.$2^n$$n$

Isso simplifica bastante as coisas: se o número original for escrito primo como , então, para todos os exceto , basta verificar que eles são todos .v i v 2$2^{v_2} 3^{v_3} 5^{v_5} 7^{v_7} ...$$v_i$$v_2$$0$

Isso nos permite resolver esse problema simplificado usando um invólucro em torno do método antigo (de Minsky, eu presumo) de codificar o estado de um autômato de contador nos expoentes da fatoração primária da variável única de um autômato de multiplicação / divisão, que, conforme observado no OP acima, é praticamente equivalente a um autômato de 2 contadores.$k$

Primeiro, precisamos de um autômato -counter para quebrar. Usaremos 3 contadores, denominados , e .v 2 v 3 v $k$$v_2$$v_3$$v_5$

O autômato aceita sse para os valores do contador iniciais, o ternário e representações binárias de têm tanto em comprimento par ou comprimento ímpar, e ambos e são zero. Quando aceita, primeiro zera todos os seus contadores. v 3 v $2^{v_2}$$v_3$$v_5$

Aqui está um código para isso, em um formato de montagem semelhante ao OP (acabei de adicionar variáveis ​​às instruções). Na verdade, eu não o testei, pois não tenho nada para executá-lo, mas considero isso uma formalidade: sabe-se que os autômatos de 3 contadores são completos para Turing e são capazes de construir qualquer função computável de um de seus componentes. valores iniciais.

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

O próximo passo é recodificar o código acima nos expoentes de um único autômato variável. Como o resultado é bastante longo, descreverei apenas o método geral, mas uma versão completa (ligeiramente "otimizada" em alguns pontos) está no meu site.

                JZ vp, label
                DEC vp
next:           ...

torna-se (basicamente divida por p e faça a limpeza para desfazer se a divisão não fosse 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 vptorna-se MUL p. Individual JZe DECpode primeiro ser alterado para o formulário combinado. GOTO labele HALT Rejectsão inalterados.

HALT Acceptpermaneceria inalterado, exceto que, no nosso caso, ainda temos uma verificação final a fazer: precisamos garantir que não haja fatores primos no número além de 2,3 e 5. Como nosso autômato de 3 contadores zera os contadores, usa quando aceita, isso é simples: basta testar se a variável final é 1, o que pode ser feito saltando para o código

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

O código no meu site também tem uma verificação inicial de que o número não é zero, o que eu acabei de perceber que é redundante com as verificações v3 e v5 zero, tudo bem.

Como mencionei, o método acima funciona para o problema simplificado, mas realmente não tem chance de trabalhar para o geral, porque: No problema geral, o valor exato do expoente de cada primo conta para decidir seu tamanho geral e, portanto, qual o seu comprimento. tem em várias bases. Isso significa que:

• Não temos números primos "gratuitos" para usar nos contadores.
• Mesmo se nós fizemos têm primos grátis para contadores, nós realmente não tenho uma maneira de extrair todas as informações necessárias dos infinitamente muitos outros primos cujos valores expoente fazer assunto.

Então, vamos terminar com uma explicação da essência do método geral do artigo acima, de Ibarra e Trân ( versão para download gratuito ), sobre como provar que certos problemas não são solucionáveis ​​por um 2CA e como isso se desagrega irritantemente em nosso caso.

$s$

Em seguida, eles analisam esse autômato para concluir que podem construir certas seqüências aritméticas de números cujo comportamento está vinculado. Para ser preciso (parte disso não é declarada como teorema, mas está implícita na prova de ambos os dois exemplos principais):

1. $v^x_i$$i$ $\leq s$$D>0$$x + n D$$n\geq 0$

2. Se um conjunto contém pelo menos números aceitos de tal modo que para cada número existe uma fase tal que , então podemos encontrar e números inteiros modo que$X$$s^2+1$$x\in X$$i$$v^x_i\leq s$$p, r\in X$$K_1,K_2$

   • Para cada inteiro , ou e São aceites pelo autómato, ou ambos são rejeitados.$n\geq 0$$p + n K_1$$r + n K_2$

(Pensamentos:

• Eles exigem para mas acho que isso é realmente desnecessário. Na verdade, é assim que eles são aceitos.$x>s$$x\in X$
• A maior parte disso também deve valer para números rejeitados , desde que a rejeição seja por interrupção explícita e não por não-terminação.)

Para seus próprios exemplos, eles também usam frequentemente o fato de que não têm fatores primos . Para provar a impossibilidade, eles derivam contradições, mostrando que tais seqüências aritméticas não podem existir.$D,K_1,K_2$$>s$

Em nosso problema, obter uma contradição com isso se divide com o segundo caso. Se temos , onde é grande o suficiente para que nenhum número entre e seja divisível por ou , também não haverá potências de 2 ou 3 entre e , de modo que ambos são aceitos ou rejeitados. 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$

O ponto 1 ainda pode ser mostrado impossível, porque as potências de 2 e 3 crescem cada vez mais distantes. E acredito que posso mostrar o segundo caso impossível se (enviei um e-mail para o argumento @MarzioDeBiasi). Então, talvez alguém possa usar essas informações para restringir ainda mais a forma do autômato e, finalmente, derivar uma contradição a partir disso.$K_1\neq K_2$