-calculus, há codificação de por ou enquanto?

7

No -calculus, podemos codificar aritmética, números, booleanos e até calcular fatoriais de números, como mostrado aqui . $\lambda$

Existe codificação de "for" ou "while"?

lambda-calculus computation-models

— alim
fonte

6

O cálculo λ está completo, portanto, sim, você pode fazer o mesmo que um loop for ou while. Eu não os chamaria de codificações , como eles são apenas funções, como tudo na λ-cálculo

— Euge

11

Certo! Deixe-me mostrar como codificar FOR usando um exemplo.

Suponha que desejemos traduzir um fator FOR simples para o programa

x := 1
for i := 1 to N do
   x := x * i

Reescrevemos como

x := 1
i := 1
repeat N times
   x := x*i
   i := i+1

então colocamos todas as variáveis que usamos em uma tupla (um par é suficiente, aqui)

(x,i) := (1,1)
repeat N times
   (x,i) := (x*i, i+1)

Isso efetivamente aplica a função para o par inicial por vezes. $\lambda\langle x,i \rangle. \langle x*i , i+1 \rangle$ $\langle 1,1 \rangle$ $N$

Como pode ser representado como um numeral da Igreja, obtemos $N$

N (λ ⟨ x, i ⟩ . ⟨ x * i, i + 1 ⟩) ⟨ 1, 1 ⟩

$N (\lambda\langle x,i \rangle. \langle x*i , i+1 \rangle) \langle 1,1 \rangle$

A sintaxe acima usa algumas coisas além do cálculo lambda simples. Números e aritmética podem ser feitos com precisão usando números da Igreja. Os pares também têm sua própria codificação da Igreja:

⟨ x, y ⟩ \equiv λ k . k x y λ ⟨ x, y ⟩ . M \equiv λ z . M {z T / x, z F / y}

$\langle x,y \rangle \equiv \lambda k.kxy \qquad \lambda \langle x,y \rangle . M \equiv \lambda z. M\{zT/x, zF/y\}$ onde é uma variável fresco, e .

z

$z$

T = λ a b . a

$T = \lambda ab.a$

F = λ a b . b

$F = \lambda ab.b$

Se você tiver mais de duas variáveis, poderá generalizar a codificação acima para tuplas ou simplesmente representar tuplas como pares aninhados.

QUANDO é melhor lidar com o uso de recursão: em vez de

while p(x,i) do
   (x,i) := f(x,i)

Onde pé um predicado e fé uma função (parcial), podemos usar algo como

def recFun(x,i):
   if p(x,i):
      return recFun(f(x,i))
   else:
      return (x,i)

No cálculo lambda, a recursão é obtida usando um combinador de ponto fixo , por exemplo, da Igreja ou Turing . Temos algo como $Y$ $\Theta$

Y (λ r . λ ⟨ x, i ⟩ . i f p x i t h e n r (f ⟨ x, i ⟩) e l s e ⟨ x, i ⟩)

$Y (\lambda r . \lambda \langle x,i \rangle . {\sf if}\ p x i\ {\sf then }\ r(f \langle x,i \rangle)\ {\sf else}\ \langle x,i \rangle)$

onde supor que os booleanos sejam codificados pela Igreja. ${\sf if}\ b\ {\sf then }\ t\ {\sf else}\ e \equiv b t e$

Observe também que WHILE é (estritamente) mais poderoso que FOR. Todo FOR pode ser codificado como WHILE, portanto, essa técnica de codificação também pode ser usada para FOR.

— chi
fonte

9

Existem codificações de loops, mas elas não funcionam exatamente como os loops com os quais você está acostumado, porque o cálculo lambda não é uma linguagem imperativa. O cálculo lambda não tem efeitos colaterais (é uma linguagem puramente funcional ); portanto, o equivalente exato de um loop seria inútil.

Estado explícito

Um programa imperativo pode ser traduzido para uma linguagem puramente funcional, passando todo o estado explicitamente como uma variável no programa. Vou usar a sintaxe Python para pseudocódigo imperativo; ele deve ser transparente na maior parte, com a indicação de que (a, b) = f(…)os meios que a chamada para a função fretorna um par e ae bsão atribuídas do primeiro e segundo componente do par, respectivamente. Considere um loop

while test_condition():
    do_stuff()

Vamos tornar o estado explícito.

state = initial_state
(state, cond) = test_condition(state)
while cond:
    (state, cond) = test_condition(do_stuff(state))

Podemos traduzir isso em uma chamada recursiva. def loop(state):define uma função chamada loop.

def loop(state):
    (state, cond) = test_condition(state)
    if cond: return loop(do_stuff(state))
    else: return state
state = loop(initial_state)

Isso usa apenas os seguintes conceitos, todos os quais podem ser expressados facilmente no cálculo lambda:

Chamadas de funções: conceito nativo
Atribuições de variáveis locais sem reatribuição: passe o valor para uma função auxiliar
Pares: Pares da Igreja
Booleanos: Booleanos da igreja
Recursão: combinadores de ponto fixo

E assim podemos definir uma whilefunção para uma condição ( ) e um corpo ( ): $C$ test_condition $B$ do_stuff

w h i l e := λ C . λ B . f i x (λ f . λ s . (λ p . BODY (f i r s t p) (s e c o n d p)) (C s)) where BODY = λ s^{'} . λ c . i f c (f (B s^{'})) s^{'}

$\mathsf{while} := \lambda C. \lambda B. \mathsf{fix} (\lambda f. \lambda s. (\lambda p. \text{BODY} (\mathsf{first}\, p) (\mathsf{second}\, p)) (C \, s)) \\ \text{where BODY} = \lambda s'. \lambda c. \mathsf{if} \, c \, (f \, (B \, s')) \, s'$

Os loops variam dependendo da linguagem de programação, mas são sempre um caso especial de loops while, para que possam ser codificados da mesma maneira. Se o idioma de origem limitar a expressividade dos loops for, pode haver codificações mais simples. Por exemplo, “repetir vezes” é simplesmente composição da função vezes, onde a função é a transformação de estado que constitui o corpo do loop, e se é um numeral da Igreja, isso simplesmente se aplica à função do corpo do loop. $n$ $n$ $n$ $n$

Adicionando estado ao idioma

Uma abordagem alternativa ao estado é estender o cálculo lambda com primitivas de manipulação de estado. Se você fizer isso, a ordem da avaliação se tornará importante. Nesse caso, um loop while pode ser expresso diretamente com recursão.

{w h i l e}_{imperative} := λ C . λ B . f i x (λ f . i f C (B; f) ())

$\mathsf{while}_{\text{imperative}} := \lambda C. \lambda B. \mathsf{fix} (\lambda f. \mathsf{if} \, C \, (B; f) \, ())$

— Gilles 'SO- parar de ser mau'
fonte