Rappresentazione di numeri negativi e complessi mediante il calcolo Lambda

La maggior parte dei tutorial su Lambda Calculus fornisce esempi in cui numeri positivi e valori booleani possono essere rappresentati da funzioni. Che dire di -1 e io?

— zcaudate
fonte

Risposte:

Prima codifica i numeri e le coppie naturali, come descritto da jmad.

Rappresenta un numero intero $k$ come coppia di numeri naturali $(a,b)$ tale che . Quindi puoi definire le normali operazioni sugli interi come (usando la notazione di Haskell per -calculus): $k = a - b$ $\lambda$

neg = \k -> (snd k, fst k)
add = \k m -> (fst k + fst m, snd k + snd m)
sub = \k m -> add k (neg m)
mul = \k m -> (fst k * fst m + snd k * snd m, fst k * snd m + snd k * fst m)

Il caso dei numeri complessi è simile nel senso che un numero complesso è codificato come una coppia di reali. Ma una domanda più complicata è come codificare i reali. Qui devi fare più lavoro:

Codifica un numero razionale $q$ come coppia $(k,a)$ dove $k$ è un numero intero, $a$ è naturale e $q = k / (1 + a)$ .
Codifica un numero reale con una funzione tale che per ogni naturale , codifica un numero razionale tale che . In altre parole, un reale è codificato come una sequenza di razionali che convergono ad esso alla velocità . $x$ $f$ $k \in \mathbb{N}$ $f k$ $q$ $|x - q| < 2^{-k}$ $k \mapsto 2^{-k}$

La codifica di reals richiede molto lavoro e non si desidera farlo effettivamente nel calcolo . Ma vedi ad esempio la sottodirectory di Marshall per una semplice implementazione dei reali in puro Haskell. In linea di principio, ciò potrebbe essere tradotto nel puro calcolo . $\lambda$ etc/haskell $\lambda$

— Andrej Bauer
fonte

Wow =) Mi chiedo intuitivamente cosa significhi ... per esempio, usando la codifica dei numeri di chiesa ... cioè. un numero di chiesa di valore intero n è rappresentato da una funzione che applica una funzione a un valore n volte. Le coppie e i valori lambda negativi hanno quella sensazione intuitiva simile su di loro?

— zcaudate,

La codifica della chiesa codifica i numeri naturali

, ... Non codifica i numeri negativi. Nella risposta sopra ho supposto che tu sapessi già di una codifica di numeri naturali, quindi ho spiegato come ottenere numeri interi. I numeri interi come li ho codificati sono una costruzione più formale, a differenza dei numeri della Chiesa, che sono collegati in modo più intricato con il calcolo

. Non credo che i "valori lambda negativi" siano una frase significativa.

0

$0$

1

$1$

2

$2$

λ

$\lambda$

— Andrej Bauer,

@zcaudate [annotazioni di tipo: i:ℤ, x:a, f,u,s:a→a, p:(a→a,a→a)] Se si codificano ℤ come (Sign,ℕ)allora, data una coppia di funzioni (s,f)come p, il termine λi.λp.λx.(fst i) (fst p) id ((snd i) (snd p) x)produrrà sia f(…f(x)…)o s(f(…f(x)…))(se il risultato è negativo). Se codifichi ℤ come (ℕ,ℕ), hai bisogno di una funzione che ha un'inverso - data una coppia (f,u)e x, la funzione λi.λp.λx.(snd i)(snd p)((fst i)(fst p) x)produrrà a u(…u(f(…f(x)…))…)cui lasceranno i tempi fapplicati . Entrambi funzionano in contesti diversi (il risultato può essere "capovolto" || è invertibile). ixf

— nessuno,

@zcaudate Le funzioni extra sono necessarie perché i numeri codificati dalla Chiesa "si basano da soli", ma le coppie ti consegneranno solo i loro componenti. Le funzioni di supporto incollano semplicemente i componenti insieme nell'ordine "giusto" (che sta accadendo automaticamente per nats.) Vedi anche: en.wikipedia.org/wiki/… - La codifica della chiesa è sostanzialmente fold . ctorper qualsiasi costruttore e quel tipo fold( r). (Ecco perché, per i tipi ricorsivi, i dati "ricorrono da soli". Per i tipi non ricorsivi è più simile a una casecorrispondenza / pattern.)

— nessuno

Il lambda-calcolo può codificare la maggior parte delle strutture di dati e dei tipi di base. Ad esempio, puoi codificare una coppia di termini esistenti nel calcolo lambda, usando la stessa codifica Church che di solito vedi per codificare interi non negativi e booleano:

paio = λ X y z . z X y

$\mbox{pair}= λxyz.zxy$

FST = λ p . p (λ X y . X)

$\mbox{fst} = λp.p(λxy.x)$

snd = λ p . p (λ X y . y)

$\mbox{snd} = λp.p(λxy.y)$

Poi la coppia è e se si vuole tornare e si può fare e . $(a,b)$ $p=(\mbox{pair }ab)$ $a$ $b$ $(\mbox{fst }p)$ $(\mbox{snd }p)$

Ciò significa che puoi rappresentare facilmente numeri interi positivi e negativi con una coppia: il segno a sinistra e il valore assoluto a destra. Il segno è un valore booleano che specifica se il numero è positivo. Il diritto è un numero naturale che usa la codifica della Chiesa.

(s i g n, n)

$(sign,n)$

E ora che hai numeri interi relativi. La moltiplicazione è facile da definire, devi solo applicare la funzione $\mbox{xor}$ sul segno e la moltiplicazione su numeri naturali sul valore assoluto:

{mult}_{ℤ} = λ a b . pair (xor (fst a) (fst b)) ({mult}_{ℕ} (snd a) (snd b))

$\mbox{mult}_ℤ=λab.\mbox{pair} ~~(\mbox{xor}(\mbox{fst }a)(\mbox{fst }b)) ~~(\mbox{mult}_ℕ(\mbox{snd }a)(\mbox{snd }b))$

Per definire l'aggiunta, devi confrontare due numeri naturali e usare la sottrazione quando i segni sono diversi, quindi questo non è un termine λ ma puoi adattarlo se vuoi davvero:

{add}_{ℤ} = λ a b . {\begin{cases} (true, {add}_{ℕ} (snd a) (snd b)) & if a \geq 0 \land b \geq 0 \\ (false, {add}_{ℕ} (snd a) (snd b)) & if a < 0 \land b < 0 \\ (true, {sub}_{ℕ} (snd a) (snd b)) & if a \geq 0 \land b < 0 \land | a | \geq | b | \\ (false, {sub}_{ℕ} (snd b) (snd a)) & if a \geq 0 \land b < 0 \land | a | < | b | \\ (true, {sub}_{ℕ} (snd b) (snd a)) & if a < 0 \land b \geq 0 \land | a | < | b | \\ (false, {sub}_{ℕ} (snd a) (snd b)) & if a < 0 \land b \geq 0 \land | a | \geq | b | \end{cases}

$\mbox{add}_ℤ=λab.\left\{\begin{array}{ll} (\mbox{true},\mbox{add}_ℕ(\mbox{snd }a)(\mbox{snd }b)) & \mbox{if } a≥0∧b≥0 \\ (\mbox{false},\mbox{add}_ℕ(\mbox{snd }a)(\mbox{snd }b)) & \mbox{if } a<0∧b<0 \\ (\mbox{true},\mbox{sub}_ℕ(\mbox{snd }a)(\mbox{snd }b)) & \mbox{if } a≥0∧b<0∧|a|≥|b| \\ (\mbox{false},\mbox{sub}_ℕ(\mbox{snd }b)(\mbox{snd }a)) & \mbox{if } a≥0∧b<0∧|a|<|b| \\ (\mbox{true},\mbox{sub}_ℕ(\mbox{snd }b)(\mbox{snd }a)) & \mbox{if } a<0∧b≥0∧|a|<|b| \\ (\mbox{false},\mbox{sub}_ℕ(\mbox{snd }a)(\mbox{snd }b)) & \mbox{if } a<0∧b≥0∧|a|≥|b| \\ \end{array}\right.$

ma poi la sottrazione è davvero facile da definire:

{minus}_{ℤ} = λ a . pair (not (fst a)) (snd a)

$\mbox{minus}_ℤ=λa.\mbox{pair}(\mbox{not}(\mbox{fst } a))(\mbox{snd } a)$

{sub}_{ℤ} = λ a b . {add}_{ℤ} (a) ({minus}_{ℤ} b)

$\mbox{sub}_ℤ=λab.\mbox{add}_ℤ(a)(\mbox{minus}_ℤb)$

$(a,b)$ $a+b\mbox{i}$

{add}_{ℤ [i]} = λ z_{1} z_{2} . pair ({add}_{ℤ} (fst z_{1}) (fst z_{2})) ({add}_{ℤ} (snd z_{1}) (snd z_{2}))

$\mbox{add}_{ℤ[\mbox{i}]}=λz_1z_2.\mbox{pair} (\mbox{add}_ℤ(\mbox{fst }z_1)(\mbox{fst }z_2)) (\mbox{add}_ℤ(\mbox{snd }z_1)(\mbox{snd }z_2))$

— jmad
fonte

Puoi evitare le distinzioni tra maiuscole e minuscole se invece rappresenti il numero intero

k

$k$ come una coppia di numeri naturali

(a, b)

$(a,b)$ tale che

k = a - b

$k = a - b$ .

— Andrej Bauer,

Gli interi complessi vanno bene, ma stava chiedendo numeri complessi. D'altra parte, ovviamente, non possono mai essere rappresentati poiché non sono numerabili.

— HdM,

@AndrejBauer: trucco molto bello (forse non così semplice) HdM: sicuro che possono farlo, anche in non tutti. Ma ho pensato che il metodo per costruire cose nel calcolo λ con la codifica della Chiesa fosse più importante / appropriato qui.

— jmad

Vorrei poter dare due risposte corrette =) Non pensavo nemmeno che i reali potessero essere rappresentati quando ho chiesto numeri complessi, ma eccoti qui !.

— zcaudate,