Restrição simplesmente declarada à linguagem de programação imperativa que captura as funções elementares?

A linguagem dos whileprogramas pode expressar as funções enumeráveis ​​computacionalmente. (Isso é verdade mesmo que as únicas operações aritméticas nas variáveis ​​sejam, por exemplo, incremento e decrementação.)

Se whilefor substituído por for, tornando os loops sempre limitados, o idioma poderá expressar apenas as funções recursivas primitivas.

Recentemente, tomei conhecimento da classe de funções elementares , estritamente abaixo das funções recursivas primitivas, mas ainda estritamente acima da hierarquia exponencial.

Obviamente, seria possível definir uma linguagem de programação imperativa que captura exatamente as funções elementares, digamos, introduzindo operadores para soma e produto limitados. No entanto, minha pergunta é:

Existe uma mudança sintática na linguagem dos whileprogramas que a restringe às funções elementares e que pode ser declarada tão simplesmente quanto a restrição ( while-> for) às funções recursivas primitivas?

Uma restrição de forprogramas também seria suficiente, é claro, e talvez eu deva esclarecer que não estou procurando algo absolutamente simples, apenas algo com simplicidade comparável que não exija a adição de operadores extras ou similares .

Edit : Um exemplo de uma forlinguagem representativa é PL- {GOTO} de "Theory of Computation" (1974) de Brainerd e Landweber, em que cada programa tem um número finito, porém irrestrito de variáveis, cada uma das quais pode conter um número natural e que consiste essencialmente nos seguintes comandos:

• X <- 0 (atribua 0 a uma variável)
• X <- Y(atribua o valor de Ya X)
• X <- Y + 1(atribua o sucessor do valor de Ya X)
• LOOP X; ... END;(repita o bloco contido de Xtempos de código ; não altera X)

Os autores comprovam que isso pode expressar exatamente as funções recursivas primitivas. A linguagem PL não corresponde perfeitamente à pergunta, pois usa em GOTOvez de while, e PL- {GOTO} é derivada de PL removendo GOTO-a. No entanto, os programas PL são tão poderosos quanto os whileprogramas, e essa GOTOtransformação de remoção é tão simplesmente declarada quanto a substituição whilepor for. (Indiscutivelmente talvez um pouco mais simples.)

O Edit 2 : http://en.wikipedia.org/wiki/Total_Turing_machine sugere que este resultado volte para: Meyer, AR, Ritchie, DM (1967), A complexidade dos programas de loop , Proc. das Reuniões Nacionais da ACM, 465.

De acordo com um resultado clássico de Meyer e Ritchie (mencionado no artigo citado na pergunta), as funções elementares são caracterizadas por programas LOOP nos quais a profundidade de aninhamento de loops for restritos é no máximo 2.

Meu palpite se baseia puramente na definição: uma resposta pode ser "restrição de loops a loops embaraçosamente paralelos for ".

Minha definição de trabalho de " forloop paralelamente embaraçoso " é aquela em que nenhuma iteração depende dos dados de qualquer outra iteração e existe uma função de redutor binário para agregar a saída (junto com um caso base). O constrangimento de bônus aponta se a função redutora é associativa, mas não sei se essa distinção limitaria o poder da linguagem.

Se limitarmos os redutores permitidos à adição e multiplicação, parece-me provável que qualquer programa implementado sob essas restrições possa ser escrito como uma função recursiva elementar (e vice-versa). Tenho menos certeza sobre redutores mais gerais.

Portanto, uma maneira divertida de colocar isso é que o único construto em loop do seu idioma é o MapReduce.

Não sou especialista na área, mas gostaria de propor isso como uma hipótese e ver quais são as opiniões das pessoas.

$O(2^{2^{\dots^{n}}})$$\dots$$k$

Isso parece claramente verdadeiro em forprogramas paralelos quando a função redutora é limitada à adição ou multiplicação, mas parece não ser verdadeira para uma escolha mais ampla de redutor. Gostaria de descobrir que podemos obter as funções elementares sempre que restringirmos o redutor a executar em tempo polinomial (a multiplicação é linear neste modelo), mas vou tentar resolver isso.

Editar 2 . Certo, parece que devemos permitir exatamente as funções redutoras que são executadas em tempo polinomial para recuperar as funções recursivas elementares. [1] Então, notamos que essa restrição não é tão interessante, porque as funções polinomiais nesse modelo são exatamente aquelas expressáveis ​​por programas com um único forloop ou um forloop paralelo com uma função redutora sem loop. Então, basicamente recuperamos a restrição de que os programas têm até dois forloops aninhados , mas acabamos de mover essa restrição para a função redutora.

Resumo: A caracterização parece ser verdadeira para redutores que são executados em tempo polinomial. Não está claro se isso é interessante.

$n$$O(n^k)$$k$for$2^{2^{\dots^n}}$

for$n$$n$$f(n)$$f(n) \in O(2^{2^{\dots^n}})$

$p$for$n$$p$$f(n)$$p(f(n),p(f(n),\dots))$$x$$x^k$$O(f(n)^{k^n})$$f(n)^{2^{2^n}}$$f(n)$$2^{\dots^n}$

$n$