Presentación - Cálculo Lambda - V4 PDF

Cálculo
Lambda:
Introducción
𝜆
Asignatura: Modelos Avanzados
Doctorado en Ingeniería
Énfasis: Ciencias de la Computación
Universidad Tecnológica de Pereira
Presentación elaborada por: Christian Andrés Candela Uribe y Luis Eduardo Sepúlveda Rodríguez
Basado en el artículo “A Tutorial Introduction to the Lambda Calculus” de Raúl Rojas (1998) 1
Contenido
| Cálculo 𝜆 | Contenido |
1. Definición
1.1. Variables libres y enlazadas
1.2. Sustituciones
2. Aritmética
2.1. Adición
2.2. Multiplicación
3. Condicionales
3.1. Operaciones lógicas
3.2. Una prueba condicional
3.3. La función predecesora
3.4. Igualdad y desigualdades
4. Recursividad
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
1. Definición
| Cálculo 𝜆 | 1. Definición |
• El cálculo λ puede ser llamado el lenguaje de programación universal más

pequeño del mundo.
• El cálculo λ consiste en:

◦ Una sola regla de transformación (sustitución de la variable).
◦ Un esquema de definición de una sola función.
• El cálculo λ fue introducido en la década de 1930 por Alonzo Church como una
manera de formalizar el concepto de computabilidad efectiva.
• El cálculo λ es universal en el sentido de que cualquier función computable

puede ser expresada y evaluada usando este formalismo.
1. Definición
| Cálculo 𝜆 | 1. Definición |
• El cálculo λ es, equivalente a las máquinas de Turing.

◦ Sin embargo, el cálculo λ enfatiza el uso de reglas de transformación y no se
preocupa por la máquina real que las implementa.
• El cálculo λ tiene un enfoque más relacionado con el software que con el

hardware.
• El concepto central en el cálculo λ es la "expresión”.
• Un "nombre” o "variable", es un identificador que puede ser cualquiera de las

letras a, b, c,. . . etc.
1. Definición
| Cálculo 𝜆 | 1. Definición | Expresión |
Expresión
• Una expresión se define recursivamente como sigue:
<expression> := <name> | <function> | <application>

<function> := λ <name> . <expression>
<application> := <expression> <expression>
• Una expresión puede ser rodeada con paréntesis para mayor claridad, es
decir, si E es una expresión, (E) es la misma expresión.
• Las únicas palabras clave utilizadas en el lenguaje son los símbolos lambda
(λ) y el punto (.).
1. Definición
| Cálculo 𝜆 | 1. Definición | Expresión |
Expresión
• Con el fin de evitar el desorden de las expresiones con paréntesis, se adopta la

convención que la aplicación de función asocia desde la izquierda, es decir, la
expresión se evalúa aplicando las expresiones de la siguiente manera:
◦ 𝐸# 𝐸$ 𝐸% … 𝐸' es equivalente a (… ((𝐸# 𝐸$ )𝐸% ) … 𝐸' )
• Como puede verse por la definición de las expresiones λ dadas anteriormente,

un identificador único es también una expresión de λ.
1. Definición
| Cálculo 𝜆 | 1. Definición | Función |
Función
• Un ejemplo de una función es el siguiente:
λx.x
• Esta expresión define la función de identidad.
• El nombre después de λ “x” es el identificador del argumento de esta función.
• La expresión después del punto “.” (en este caso una sola x) se llama el
"cuerpo" de la definición.
1. Definición
| Cálculo 𝜆 | 1. Definición | Aplicación |
Aplicación
• Las funciones se pueden aplicar en las expresiones, a esto se le denomina una

aplicación. Un ejemplo de una aplicación es
(λx.x) y
• Esta es la función identidad aplicada a y.
• Los paréntesis se utilizan para mayor claridad a fin de evitar la ambigüedad.
• Las aplicaciones de la función se evalúan sustituyendo el valor del argumento

x (en este caso y) en el cuerpo de la definición de la función, es decir,
(λx.x) y = [y / x] x = y
1. Definición
| Cálculo 𝜆 | 1. Definición | Aplicación |
Aplicación
• Los nombres de los argumentos en las definiciones de funciones no tienen

ningún significado por sí mismos.
• Los nombres son sólo "marcador de posición”.
• Se utilizan para indicar cómo reorganizar los argumentos de la función

cuando se evalúa. Por lo tanto las siguientes expresiones son equivalentes.
(λz.z) ≡ (λy.y) ≡ (λt.t) ≡ (λu.u) ... Etc.
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
| Cálculo 𝜆 | 1. Definición | 1.1 Variables libres y enlazadas |
• En el cálculo λ todos los nombres son locales a las definiciones.
• En la función λx.x decimos que x está "unido” (enlazado) ya que su ocurrencia

en el cuerpo de la definición es precedida por λx.
• Un nombre no precedido por un λ se llama una "variable libre”.
• En la expresión (λx.xy) la variable x está enlazada y y está libre.
• Ejemplo:
◦ (λx.x) (λy.yx)
◦ La x en el cuerpo de la primera expresión desde la izquierda está
enlazada a la primera λ.
◦ La y en el cuerpo de la segunda expresión está enlazada a la segunda λ y

la x está libre.
◦ Es muy importante notar que la x en la segunda expresión es totalmente

independiente de la x en la primera expresión.
• Formalmente decimos que una variable está libre en una expresión si se

cumple uno de los tres casos siguientes:
1. <nombre> está libre en <nombre>.
2. <nombre> está libre en λ <nombre1>. <exp> si el identificador <nombre>

≠ <nombre1> y <nombre> está libre en <exp>.
3. <nombre> está libre en E1 E2 si <nombre> está libre en E1 o si está libre

en E2.
• Una variable está enlazada si uno de dos casos se cumple:
1. <nombre> está enlazado en λ <nombre1>. <exp> si el identificador

<nombre> <nombre1> o si <nombre> está enlazado en <exp>.
2. <nombre> está enlazado en E1 E2 si <nombre> está enlazado en E1 o si

está enlazado en E2.
• Debe enfatizarse que el mismo identificador puede estar libre y enlazado en

la misma expresión. En la expresión
(λx.xy) (λy.y)
◦ En la primera subexpresión entre paréntesis, el primer y está libre, pero

está enlazada en la subexpresió de la derecha.
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
1.2. Sustituciones
| Cálculo 𝜆 | 1. Definición | 1.2 Sustituciones |
• Posiblemente el hecho mas confuso al abordar el estudio del cálculo λ por

primera vez, es que no se asignan nombres a las funciones.
• Cada vez que queremos aplicar una función, escribimos toda la definición de
función y luego procedemos a evaluarla.
• Para simplificar la notación, sin embargo, es posible usar mayúsculas, dígitos

y otros símbolos como alias o macros para algunas definiciones de funciones.
• La función de identidad, por ejemplo, se puede denotar con I que es un alias

de (λx.x).
1.2. Sustituciones
• Por ejemplo la función de identidad aplicada a sí misma corresponde a lo

siguiente:
II ≡ (λx.x) (λx.x)
• En esta expresión la primera x en el cuerpo de la primera expresión entre

paréntesis es independiente de la x en el cuerpo de la segunda expresión. De
hecho, podemos reescribir la expresión anterior como II ≡ (λx.x) (λz.z)
• La función de identidad aplicada a sí misma
II ≡ (λx.x) (λz.z)
• Realizando la sustitución se produce lo siguiente
◦ [λz.z / x] x = λz.z ≡ I, es decir, la función de identidad de nuevo.
1.2. Sustituciones
• Debemos tener cuidado al realizar sustituciones para evitar mezclar las

ocurrencias libres de un identificador con las enlazadas. Por ejemplo,
considerando la siguiente expresión:
( λx. ( λy.xy ) ) y
• La función a la izquierda contiene una y enlazada, mientras que la y a la

derecha es libre. Una sustitución incorrecta mezclaría los dos identificadores
en un resultado erróneo.
( λy.yy ) ß Error
• Simplemente cambiando el nombre de y a t obtenemos lo siguiente:
◦ ( λx. ( λt.xt ) ) y = ( λt.yt ), que es un resultado completamente diferente

pero, sin embargo, el correcto.
1.2. Sustituciones
• Por lo tanto, si la función λx. <exp> se aplica a E, sustituimos todas las

ocurrencias libres de x en <exp> con E. Si la sustitución traería una variable
libre de E en una expresión en la que esta variable se encuentra enlazada,
cambiamos el nombre a la variable enlazada antes de realizar la sustitución .
• Por ejemplo, en la expresión siguiente sólo debemos asociar el argumento x

con y en el cuerpo de la función.
( λx.( λy.( x ( λx.xy ) ) ) ) y
• Antes de realizar la asociación de argumentos, es necesario cambiar variables

para evitar errores así:
( λx.( λy.( x ( λx.xy ) ) ) ) y ≡ ( λx.( λt.( x ( λx.xt ) ) ) ) y
1.2. Sustituciones
( λx.( λt.( x ( λx.xt ) ) ) ) y
◦ Continuando con la sustitución el procedimiento queda así:
[y/x]( λx.( λt.( x ( λx.xt ) ) ) )

( λt.( y ( λx.xt ) ) )
• En la reducción de orden normal tratamos de reducir siempre la expresión

más a la izquierda de una serie de aplicaciones.
• Se deber continuar hasta que no se produzcan reducciones adicionales.
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
2. Aritmética
| Cálculo 𝜆 | 2. Aritmética |
• Los números se pueden representar en el cálculo λ a partir de cero y escribir

"suc (cero)" para representar 1, "suc (suc (cero))" para representar 2, y así
sucesivamente.
• En el cálculo λ sólo podemos definir nuevas funciones, por lo tanto los

números se definirán como funciones utilizando el siguiente enfoque: cero se
puede definir así:
λs.(λz.z)
0 ≡ λsz.z
• Esta es una función de dos argumentos s y z. Vamos a abreviar estas

expresiones con más de un argumento como λsz.z
• Se entiende aquí que s es el primer argumento a ser sustituido durante la

evaluación y z el segundo.
2. Aritmética
• Se presenta a continuación la primera función interesante, la función

sucesora, la cual se define como sigue:
S ≡ λwyx.y(wyx)
• La función sucesora aplicada a la representación para rendimientos cero se

expresa así: S 0
S0 ≡ (λwyx.y(wyx))(λsz.z)
• En el cuerpo de la primera expresión sustituimos todas las ocurrencias de w

por (λsz.z) y esto produce 1.
2. Aritmética
• Usando esta notación, el cero y los primeros números naturales se pueden

definir así:
0 ≡ λsz . z
1 ≡ λsz . s (z)
2 ≡ λsz . s (s (z))
3 ≡ λsz . s (s (s (z)))
4 ≡ λsz . s (s (s (s (z))))
5 ≡ λsz . s (s (s (s (s (z)))))
6 ≡ λsz . s (s (s (s (s (s (z))))))
• y así sucesivamente.
2. Aritmética
• La función sucesora aplicada al 0 produce 1.

S 0
S0 ≡ (λwyx.y(wyx))(λsz.z) ≡ 1
• En el cuerpo de la primera expresión sustituimos todas las ocurrencias de w
por (λsz.z) y esto produce lo siguiente:
(λwyx.y(wyx)) (λsz.z)
[(λsz.z)/w] (λwyx.y(wyx))
(λyx.y((λsz.z)yx))
(λyx.y((λsz.z)yx))
(λyx.y([y/s](λsz.z)x))
(λyx.y(λz.z)x)
(λyx.y[x/z](λz.z))
(λyx.y(x))
Es decir, obtenemos la representación del número 1.
(λyx.y(x)) ≡ λsz.s(z) ≡ 1
2. Aritmética
• La función sucesora aplicada al 1 produce el 2
• S1 ≡ (λwyx.y (wyx)) (λsz.s (z)) = λyx.y ( (λsz.s (z)) yx) = λyx.y (y (x)) ≡ 2
• Procedimiento:
S1 ≡ (λwyx.y (wyx)) (λsz.s (z))
= [(λsz.s (z)) / w] (λwyx.y (wyx))
= λyx.y ((λsz.s (z))yx)
= λyx.y ([y/s] λsz.s (z) ) x)
= λyx.y ((λz.y (z)) x)
= λyx.y ([x/z] (λz.y (z) ) )
= λyx.y (y (x) ) ≡ λsz.s (s (z) ) ≡ 2
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
3.4. Igualdad e independencia
4. Recursividad
2.1. Adición
| Cálculo 𝜆 | 2. Aritmética | 2.1. Adición |
• La adición se puede obtener inmediatamente observando que el cuerpo sz de

la definición del número 1, por ejemplo, se puede interpretar como la
aplicación de la función s sobre z así:
1 ≡ λsz .s (z)
• Si queremos añadir 2 al 3, simplemente aplicamos la función sucesora dos

veces a 3.
• Vamos a calcular 2 + 3 haciendo lo siguiente:

2 S 3
2S3 ≡ (λsz.s(s(z))) (λwyx.y(wyx)) (λuv.u(u(u(v))))
2.1. Adición
2 S 3
2S3 ≡ (λsz.s(s(z))) (λwyx.y(wyx)) (λuv.u(u(u(v))))
• La primera expresión en el lado derecho es a 2, la segunda es la función

sucesora, la tercera es a 3 (se han renombrado las variables para dar mayor
claridad).
• La expresión anterior se reduce a
(λwyx.y ((wy) x)) (λwyx.y ((wy) x)) (λuv. u (u (u(v)))) ≡ SS3
2.1. Adición
• Ejemplo: comprobación de la equivalencia 2S3 ≡ SS3
(λsz.s(s(z))) (λwyx.y(wyx)) (λuv.u(u(u(v))))
[(λwyx.y(wyx))/s](λsz.s(s(z))) (λuv.u(u(u(v))))
(λz. (λwyx.y(wyx))((λwyx.y(wyx))(z))) (λuv.u(u(u(v))))
(λz. (λwyx.y(wyx))((λwyx.y(wyx))(z))) (λuv.u(u(u(v))))
[(λuv.u(u(u(v))))/z](λz. (λwyx.y(wyx))((λwyx.y(wyx))(z)))
(λwyx.y(wyx)) ((λwyx.y(wyx)) (λuv.u(u(u(v))))
• Por lo tanto la comprobación resulta en que 2S3 ≡ S(S3)
2.1. Adición
• Ejemplo: Verificando que S(S3) reduce a S4 ≡ (λwyx.y ((wy) x)) (λwyx.y

((wy) x)) (λuv. u (u (u(v)))) reduce a S4:
(λwyx.y ((wy) x)) (λwyx.y ((wy) x)) (λuv.u (u (u (v))))
(λwyx.y ((wy) x))[ (λuv.u (u (u(v)))) / w] (λwyx.y ((w (y)) x))
(λwyx.y ((wy) x)) (λyx.y (((λuv.u (u (u (v)))) y) x) )
(λwyx.y ((wy) x)) (λyx.y (([y / u](λuv.u (u (u(v))))) x) )
(λwyx.y ((wy) x)) (λyx.y (λv.y (y (y (v)))) x)
(λwyx.y ((wy) x)) (λyx.y [x/v] (λv.y (y (y (v))))
(λwyx.y ((wy) x))(λyx.y (y (y (y (x)))) ≡ S4
2.1. Adición
• Ejemplo:
• Verificando que S4 reduce a 5 ≡ (λwyx.y ((wy) x)) (λuv.v (u (u (u (v)))):
(λwyx.y ((wy) x)) (λuv. u (u (u (u (v))))
[(λuv. u (u (u (u (v)))) / w](λwyx.y ((wy) x))
(λyx.y (((λuv. u (u (u (u (v))))y) x))
λyx.y (([y/u](λuv. u (u (u (u (v))))) x)
λyx.y ((λv. y (y (y (y (v))))) x)
λyx.y (([x/v]λv. y (y (y (y (v)))))
λyx. y ( y (y (y (y (x)) ) ) ) ≡ 5

Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
| Cálculo 𝜆 | 2. Aritmética | 2.2. Multiplicación |
• La multiplicación de dos valores x y y se puede calcular utilizando la siguiente

función:
( λxyz.x ( yz))
• Ejemplo: el producto de 2 por 2 es entonces el siguiente:
◦ ( λxyz.x (yz) ) 2 2
◦ Se reduce a
◦ ( λz. 2 ( 2z ) )
• Verificando que al reducir aún más esta expresión, podemos obtener el

resultado esperado 4 así:
◦ ( λxyz.x (yz)) 2 2
◦ = [2/x]( λxyz.x (yz) ) 2
◦ = ( λyz.2 (yz) ) 2
◦ = [2/y]( λyz.2 (yz) )
◦ = λz.2 ( 2 z )
◦ Para evitar confusión en la sustitución cambiamos variables así:
◦ λz.2 ( 2 z ) ≡ λt. 2 ( 2 t )
◦ Reemplazamos el símbolo 2 en términos de la función que lo representa así:
◦ 2 ≡ λsz . s ( s ( z ) ) y tenemos lo siguiente:
◦ λt. 2 (2 t) ≡ λt. λsz . s ( s ( z ) ) λsz . s ( s ( z ) ) t
◦ λt. λsz . s ( s ( z ) ) λsz . s ( s ( z ) ) t
◦ λt. λsz . s ( s ( z ) ) [t /s] λsz . s ( s ( z ) )
◦ λt. λsz . s ( s ( z ) ) λz . t ( t ( z ) )
◦ Para evitar confusión en la sustitución cambiamos variables así:

◦ λt. λsz . s ( s ( z ) ) λz . t ( t ( z ) ) ≡ λt. λsz . s ( s ( z ) ) λa . t ( t ( a ) )
◦ λt. λsz . s ( s ( z ) ) λa . t ( t ( a ) )
◦ λt. [λa . t ( t ( a ) )/s] λsz . s ( s ( z ) )
◦ λt. λz . λa . t ( t ( a ) ) ( λa . t ( t ( a ) ) ( z ) )
◦ λt. λz . λa . t ( t ( a ) ) ( [z/a] λa . t ( t ( a ) ) )
◦ λt. λz . λa . t ( t ( a ) ) ( t ( t ( z ) ) )
◦ λt. λz . [( t ( t ( z ) ) )/a] λa . t ( t ( a ) )
◦ λt. λz . t ( t ( ( t ( t ( z ) ) ) ) )
◦ Se puede utilizar la abreviación de la expresión así:
◦ λt. λz . t ( t ( ( t ( t ( z ) ) ) ) ) ≡ λtz . t ( t ( ( t ( t ( z ) ) ) ) )
◦ Esto es igualmente equivalente a 4 así:
◦ λtz . t ( t ( ( t ( t ( z ) ) ) ) ) ≡ λsz . s ( s ( s ( s ( z ) ) ) ) ≡ 4
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
3. Condicionales
| Cálculo 𝜆 | 3. Condicionales |
• Introducimos las siguientes dos funciones que llamamos los valores

"verdadero” (True)
T ≡ λxy.x
• y "falso” (False)
F ≡ λxy.y
• La primera función toma dos argumentos y devuelve la primera, la segunda

función devuelve el segundo de dos argumentos.
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 3.1. Operaciones lógicas |
• A continuación se definen operaciones lógicas usando esta representación de

los valores de verdad así:
• La función AND:
∧ ≡ λxy.xy (λuv.v) ≡ λxy.xyF
• La función OR:
∨ ≡ λxy.x (λuv.u) y ≡ λxy.xTy
• La función negación:
¬ ≡ λx.x (λuv.v) (λab.a) ≡ λx.xFT
• Ejemplo:
◦ La función de negación aplicada a "verdadero” (True) es
◦ ¬T ≡ λx.x (λuv.v) (λab.a) (λcd.c)
◦ Se reduce a:
◦ TFT ≡ (λcd.c) (λuv.v) (λab.a) = (λuv.v) ≡ F , es decir, el valor de verdad

"falso".
• Demostración: ¬T ≡ F
◦ (λx.x (λuv.v) (λab.a)) (λcd.c)
◦ [(λcd.c)/x](λx.x (λuv.v) (λab.a))
◦ (λcd.c)(λuv.v) (λab.a) ≡ TFT
◦ [(λuv.v)/c] (λcd.c)(λab.a)
◦ (λd. (λuv.v))(λab.a)
◦ [(λab.a)/d](λd. (λuv.v))
◦ (λuv.v) ≡ F
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 3.2. Una prueba condicional |
• A continuación se presenta la función Z que reduce a verdadero si un número

es cero o falso en caso contrario.
Z ≡ λx.xF¬F
• Para entender cómo funciona esta función, tenga en cuenta que
0fa ≡ (λsz.z) fa = a
• es decir, la función f se aplica cero veces al argumento a produce a. Por otro

lado, F aplicado a cualquier argumento produce la función de identidad
Fa ≡ (λxy.y) a = λy.y ≡ I
• Ahora podemos probar si la función Z funciona correctamente. La función Z

aplicada a cero debe producir T así:
• Z0 ≡ (λx.xF¬F) 0
• = 0 F ¬F
• = ¬F
• = T
• Z0 ≡ T
• Ejemplo, evaluación de 0 en Z:
Z0 ≡ T
Z0 ≡ (λx.xF¬F) (λsz.z)
= [(λsz.z)/x](λx.xF¬F)
= (λsz.z) F ¬ F
= (λsz.z) (λab.b) ((λx.x (λuv.v) (λab.a)) (λcd.d))
= [(λab.b) /s] (λsz.z) ((λx.x (λuv.v) (λab.a)) (λcd.d))
= (λz.z) ((λx.x (λuv.v) (λab.a)) (λcd.d))
= [((λx.x (λuv.v) (λab.a)) (λcd.d)) / z](λz.z)
= (λx.x (λuv.v) (λab.a)) (λcd.d)
= [(λcd.d)/x](λx.x (λuv.v) (λab.a))
= (λcd.d) (λuv.v) (λab.a) ≡ FFV
= [(λuv.v) /c](λcd.d) (λab.a)
= (λd.d) (λab.a)
= [(λab.a)/d](λd.d)
= (λab.a) ≡ T
• La función Z aplicada a cualquier otro número N produce F
ZN ≡ (λx.xF¬F) N = NF ¬F = IF = F
• La función F se aplica entonces N veces a ¬. Pero F aplicado a cualquier cosa es

la identidad (I), de modo que la expresión anterior se reduce para cualquier
número N mayor que cero a
• Ejemplo: Evaluación de n en Z y n es • [ ¬ / x ] (λxy.y)

diferente de cero: • λy.y que es la identidad … Entonces
tendríamos.
• Zn ≡ ( 𝜆x.xF¬F ) n • Zn ≡ F(F(F( … I…))) F
• Se remplaza n en x • Pero por igual demostración F( I ) seria I
• Zn ≡ [ n / x ] ( 𝜆x.xF¬F ) que aplicado n veces seguiría siendo I
• Zn ≡ n F¬F entonces F(F(F( … I…))) es I
• Se remplaza n por su función λsz.s(s(s( • Zn ≡ I F
…s(z)…))) • Zn ≡ λx.x F
• Zn ≡ λsz.s(s(s( …s(z)…))) F¬F • Si se remplaza F en x así:
• Se remplaza F en s • Zn ≡ [ F / x ] λx.x
• Zn ≡ [ F / s] (λsz.z) ¬F • Zn ≡ F
• Zn ≡ λz.F(F(F( …F(z)…))) ¬F
• Se remplaza ¬ en z
• Zn ≡ [¬ / z ] λz.F(F(F( …F(z)…))) F
• Zn ≡ F(F(F( …F(¬)…))) F
• F(¬) es
• (λxy.y) (¬)
• Si se remplaza (¬) en x tenemos
| Cálculo 𝜆 | 3. Condicionales | 3.2. Una prueba condicional | Ejemplos |
Ejemplo: Tabla de verdad AND
AND ≡ ∧ ≡ λxy.xy (λuv.v) ≡ λxy.xyF
∧ T T ≡ T
∧ T F ≡ F
∧ F T ≡ F
∧ F F ≡ F
Tablas de verdad
Ejemplos de AND demostrando que ∧ T T ≡ T
∧ T T ≡ T
• (λxy.xy (λuv.v)) (λab.a) (λcd.c)
• [(λab.a) /x] (λxy.xy (λuv.v)) (λcd.c)
• (λy. (λab.a) y (λuv.v)) (λcd.c)
• [(λcd.c)/y] (λy. (λab.a) y (λuv.v))
• (λab.a) (λcd.c) (λuv.v) ≡ TTF
• [(λcd.c)/a] (λab.a) (λuv.v)
• λb. (λcd.c) (λuv.v)
• [(λuv.v)/b] λb. (λcd.c))
• (λcd.c) ≡ T
Tablas de verdad
Ejemplos de AND demostrando que ∧ T F ≡ F
∧ T F ≡ F
• (λxy.xy (λuv.v)) (λab.a) (λcd.d)
• [(λab.a) /x] (λxy.xy (λuv.v)) (λcd.d)
• (λy. (λab.a) y (λuv.v)) (λcd.d)
• [(λcd.d)/y] (λy. (λab.a) y (λuv.v))
• (λab.a) (λcd.d) (λuv.v) ≡ TFF
• [(λcd.d)/a] (λab.a) (λuv.v)
• λb. (λcd.d) (λuv.v)
• [(λuv.v)/b] λb. (λcd.d))
• (λcd.d) ≡ F
Tablas de verdad
Ejemplos de AND demostrando que ∧ F T ≡ F
∧ F T ≡ F
• (λxy.xy (λuv.v)) (λab.b) (λcd.c)
• [(λab.b) /x](λxy.xy (λuv.v)) (λcd.c)
• (λy. (λab.b) y (λuv.v)) (λcd.c)
• [(λcd.c)/y](λy. (λab.b) y (λuv.v))
• (λab.b) (λcd.c) (λuv.v) ≡ TTF
• [(λcd.c)/a](λab.b) (λuv.v))
• λb. b (λuv.v)
• [(λuv.v)/b] λb. b )
• (λuv.v) ≡ F
Tablas de verdad
Ejemplos de AND demostrando que ∧ F F ≡ F
∧ F F ≡ F
• (λxy.xy (λuv.v)) (λab.b) (λcd.d)
• [(λab.b) /x](λxy.xy (λuv.v)) (λcd.d)
• (λy. (λab.b) y (λuv.v)) (λcd.d)
• [(λcd.d)/y](λy. (λab.b) y (λuv.v))
• (λab.b) (λcd.d) (λuv.v) ≡ FFF
• [(λcd.d)/a](λab.b) (λuv.v)
• λb. b (λuv.v)
• [(λuv.v)/b] λb. b)
• (λuv.v) ≡ F
Tablas de verdad
OR ≡ ⋎ ≡ λxy.x (λuv.u) y ≡ λxy.xTy
⋎ T T ≡ T
⋎ T F ≡ T
⋎ F T ≡ T
⋎ F F ≡ F
Tablas de verdad
Ejemplos de OR demostrando que ⋎ T T ≡ T
⋎ T T ≡ T
• (λxy. x (λuv.u) y) (λab.a) (λcd.c)
• [(λab.a) /x](λxy. x (λuv.u) y) (λcd.c)
• (λy. (λab.a) (λuv.u) y) (λcd.c)
• [(λcd.c)/y](λy. (λab.a) (λuv.u) y)
• (λab.a) (λuv.u) (λcd.c) ≡ TTT
• [(λuv.u)/a](λab.a) (λcd.c)
• (λb. (λuv.u)) (λcd.c)
• [(λcd.c)/b](λb. (λuv.u))
• (λuv.u) ≡ T
Tablas de verdad
Ejemplos de OR demostrando que ⋎ T F ≡ T
⋎ T F ≡ T
• (λxy. x (λuv.u) y) (λab.a) (λcd.d)
• [(λab.a) /x](λxy. x (λuv.u) y) (λcd.d)
• (λy. (λab.a) (λuv.u) y) (λcd.d)
• [(λcd.d)/y](λy. (λab.a) (λuv.u) y)
• (λab.a) (λuv.u) (λcd.d) ≡ TTF
• [(λuv.u)/a](λab.a) (λcd.d)
• (λb. (λuv.u)) (λcd.d)
• [(λcd.d)/b](λb. (λuv.u))
• (λuv.u) ≡ T
Tablas de verdad
Ejemplos de OR demostrando que ⋎ F T ≡ T
⋎ F T ≡ T
• (λxy. x (λuv.u) y) (λab.b) (λcd.c)
• [(λab.b) /x](λxy. x (λuv.u) y) (λcd.c)
• (λy. (λab.b) (λuv.u) y) (λcd.c)
• [(λcd.c)/y](λy. (λab.b) (λuv.u) y)
• (λab.b) (λuv.u) (λcd.c) ≡ FTT
• [(λuv.u)/a](λab.b) (λcd.c)
• (λb. b) (λcd.c)
• [(λcd.c)/b] (λb. b)
• (λcd.c) ≡ T
Tablas de verdad
Ejemplos de OR demostrando que ⋎ F F ≡ F
⋎ F F ≡ F
• (λxy. x (λuv.u) y) (λab.b) (λcd.d)
• [(λab.b) /x](λxy. x (λuv.u) y) (λcd.d)
• (λy. (λab.b) (λuv.u) y) (λcd.d)
• [(λcd.d)/y](λy. (λab.b) (λuv.u) y)
• (λab.b) (λuv.u) (λcd.d) ≡ FTF
• [(λuv.u)/a](λab.b) (λcd.d)
• (λb. b) (λcd.d)
• [(λcd.d)/b](λb. b)
• (λcd.d) ≡ F
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 3.3. La función predecesora |
• La función predecesora se define combinando varias funciones presentadas

anteriormente.
• Al buscar el predecesor de n, la estrategia general será crear un par (n, n-1) y

luego escoger el segundo elemento del par como resultado.
• Un par (a, b) se puede representar en λ-cálculo utilizando la función (λz.zab)
• Para extraer el primer elemento del par de la expresión se aplica esta función
a T así:
◦ (λz.zab) T = Tab = a
• Para extraer el segundo elemento se aplica la función a F así:

◦ (λz.zab) F = Fab = b
• La siguiente función genera a partir del par (n, n-1) (que es el argumento p en
la función) el par (n+1, n):
Φ ≡ (λpz.z (S (pT)) (pT))
• La subexpresión pT extrae el primer elemento del par p. Se forma un nuevo

par utilizando este elemento, el cual se incrementa para la primera posición
del nuevo par y se copia para la segunda posición del nuevo par.
• El predecesor de un número n se obtiene aplicando n veces la función Φ al par

(λz.z00) y luego seleccionando el segundo miembro del nuevo par:
P ≡ (λn.n Φ (λz.z00)F)
• Observe que con este enfoque el predecesor de cero es cero. Esta propiedad es
útil para la definición de otras funciones.
Demostración: ( 𝜆z.zab ) F ≡ Fab ≡ b

Esto es:
Remplazamos F en z
Sea
[ F / z ] ( 𝜆z.zab )
𝜆z.zab
F a b
Si se quiere obtener a
Remplazando F por su función lambda tenemos
( 𝜆z.zab ) T ≡ Tab ≡ a
𝜆xy.y a b
Esto es:
Remplazamos a en x
Remplazar T en z
[ a / x ] 𝜆xy.y b
[ T / z ] ( 𝜆z.zab )
𝜆y.y b
Tab
Remplazamos b en y
Remplazando T por su función landa tenemos
[ b / y ] 𝜆y.y
𝜆xy.x a b
b
Remplazamos a en x
Entonces si se tuviera el par a = n y b = n -1 se podría
[ a / x ] 𝜆xy.x b obtener b.
𝜆y.a b La siguiente función genera el par n+1,n a partir del
Remplazamos b en y par ( n, n-1 ). Se asume p como el par n,n-1.
[ b /y ] 𝜆y.a Φ = ( 𝜆pz.z ( S(pT)) (pT) )
a
Ejemplo 1:
Calculemos Φ con el par 5,4 ( 𝜆n.n 5 4 ), es decir Φ ( 𝜆z.z 5 4 ) así:

Φ ( 𝜆z.z 5 4 ) ≡ ( 𝜆pz.z ( S(pT)) (pT) ) ( 𝜆n.n 5 4 )
( 𝜆pz.z ( S(pT)) (pT) ) ( 𝜆n.n 5 4 )
Remplazamos ( 𝜆n.n 5 4 ) en p
[( 𝜆n.n 5 4 ) / p ] ( 𝜆pz.z (S(pT)) (pT) )
(𝜆z.z ( S( ( 𝜆n.n 5 4 ) T)) ( ( 𝜆n.n 5 4 )T ) )
Remplazamos T en n
[ T / n ] ( 𝜆z.z ( S( ( 𝜆n.n 5 4 ) )) ( ( 𝜆n.n 5 4 ) ) )
( 𝜆z.z ( S ( T 5 4 ) ) ( T 5 4 ) )
Como T retorna el primer parámetro tenemos T 5 4 ≡ 5
( 𝜆z.z ( S( 5 ) ) (5) )
Como S(5) es 6 entonces
( 𝜆z.z 6 5 )
La función predecesor de n es obtenida al aplicar la función Φ n veces al par 0 , 0. Como resultado de aplicar
la función Φ n veces al par 0 , 0 se obtendrá el par n+1,n tras lo cual solo resta aplicar a dicha función la
función F para obtener el n.
Entonces
P ≡ ( 𝜆n.n Φ ( 𝜆z.z0 0 ) F )
Ejemplo 2: Buscar el predecesor de 5 Como Φ ( ( 𝜆z.z 2 1 ) ) es ( 𝜆z.z 3 2 ) entonces

P 5 ≡ Φ (Φ ( ( 𝜆z.z 3 2 ) )) F
Al evaluar P 5 tenemos Como Φ ( ( 𝜆z.z 3 2 ) ) es ( 𝜆z.z 4 3 ) entonces
P 5 ≡ ( 𝜆n.n Φ ( 𝜆z.z0 0 ) F ) 5 P 5 ≡ Φ ( ( 𝜆z.z 4 3 ) ) F
Remplazamos 5 en n Como Φ ( ( 𝜆z.z 4 3 ) ) es ( 𝜆z.z 5 4 ) entonces
P 5 ≡ [ 5 / n ] ( 𝜆n.n Φ ( 𝜆z.z0 0 ) F ) P 5 ≡ ( 𝜆z.z 5 4 ) F
P 5 ≡ 5 Φ ( 𝜆z.z0 0 ) F Remplazamos F en z
Sustituyendo 5 por su equivalente en función lambda [ F / z ] ( 𝜆z.z 5 4 )
λsr.s(s(s(s(s(r))))) tenemos P 5 ≡ F 5 4
P 5 ≡ λsr.s(s(s(s(s(r))))) Φ ( 𝜆z.z0 0 ) F F retorna el segundo parámetro por lo que F 5 4 es 4
Remplazamos Φ en s y tenemos entonces
P 5 ≡ [ Φ / s ] λsr.s(s(s(s(s(r))))) ( 𝜆z.z0 0 ) F P5 ≡ 4
P 5 ≡ λr. Φ (Φ (Φ (Φ (Φ (r))))) ( 𝜆z.z0 0 ) F
Remplazamos ( 𝜆z.z0 0 ) en r
P 5 ≡ [ ( 𝜆z.z0 0 ) / r ] λr. Φ (Φ (Φ (Φ (Φ (r))))) F
P 5 ≡ Φ (Φ (Φ (Φ (Φ ( ( 𝜆z.z0 0 ) ))))) F
Teniendo presente que Φ ( 𝜆z.z0 0 ) es ( 𝜆z.z 1 0 )
entonces
P 5 ≡ Φ (Φ (Φ (Φ ( ( 𝜆z.z 1 0 ) )))) F
Como Φ ( 𝜆z.z 1 0 ) es ( 𝜆z.z 2 1 ) entonces
P 5 ≡ Φ (Φ (Φ ( ( 𝜆z.z 2 1 ) ))) F
Ejemplo 2: P0 ≡ F 0 0
F retorna el segundo parámetro por lo que F 0 0 es 0
Es importante tener en cuenta que si se llama la P0 ≡ 0
función predecesora con cero como parámetro, el Entonces predecesor de 0 es 0
resultado es 0. Entonces predecesor de 0 es 0
Al evaluar P 0 tenemos
P0 ≡ ( 𝜆n.n Φ ( 𝜆z.z0 0 ) F ) 0
Se remplaza 0 en n
P0 ≡ [ 0 / n ] ( 𝜆n.n Φ ( 𝜆z.z0 0 ) F )
P0 ≡ 0 Φ ( 𝜆z.z0 0 ) F
Sustituyendo 0 por su función lambda (λsr.r) tenemos
P0 ≡ λsr.r Φ ( 𝜆z.z0 0 ) F
Remplazamos Φ en s
P0 ≡ [ Φ / s ] λsr.r ( 𝜆z.z0 0 ) F
P0 ≡ λr.r ( 𝜆z.z0 0 ) F
Remplazamos ( 𝜆z.z0 0 ) en r
P0 ≡ [ ( 𝜆z.z0 0 ) / r ] λr.r F
P0 ≡ ( 𝜆z.z0 0 ) F
Remplazamos F en z
P0 ≡ [ F / z ] ( 𝜆z.z0 0 )
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 3.4. Igualdad y desigualdades | Función mayor o igual que |
Función mayor o igual que
• La función G para evaluar si x es mayor o igual que y así:
G ≡ ( 𝜆xy. Z ( xPy ) )
• Si al aplicar la función predecesor P a Y X veces el resultado de Z será verdadero si X es

mayor o igual que Y, en caso contrario será falso
Ejemplos: G 4 4 ≡ Z( P( P ( 2 ) ) )
Como P(2) es 1 entonces
• Evaluar a >= b cuando a es 4 y b es 4 G 4 4 ≡ Z( P( 1 ) )
G 4 4 ≡ ( 𝜆xy. Z ( xPy ) ) 4 4 G 4 4 ≡ Z( 0 )
Remplazar 4 en x Z0 es T entonces
G 4 4 ≡ [ 4 / x ] ( 𝜆xy. Z ( xPy ) ) 4 G 4 4 ≡ T
G 4 4 ≡ ( 𝜆y.Z( 4Py ) ) 4
Remplazar 4 en y
G 4 4 ≡ [ 4 / y ] ( 𝜆y. Z ( 4Py ) )
G 4 4 ≡ Z ( 4P4 )
4 P 4 es P( P ( P ( P ( 4 ) ) ) )
G 4 4 ≡ Z( P( P ( P ( P ( 4 ) ) ) ) )
Como P (4) es 3 entonces
G 4 4 ≡ Z ( P ( P ( P ( 3 ) ) ) )
Ejemplos: G 4 5 ≡ Z ( P ( P ( 3 ) ) )
• Evaluar a >= b cuando a es 4 y b es 5 G 4 5 ≡ Z ( P ( 2 ) )
G 4 5 ≡ ( 𝜆xy. Z ( xPy ) ) 4 5 G 4 5 ≡ Z ( 1 )
Remplazar 4 en x Z1 es F entonces
G 4 5 ≡ [ 4 / x ] ( 𝜆xy. Z ( xPy ) ) 5 G 4 5 ≡ F
G 4 5 ≡ ( 𝜆y. Z ( 4Py ) ) 5
Remplazar 5 en y
G 4 5 ≡ [ 5 / y ] ( 𝜆y. Z ( 4Py ) )
G 4 5 ≡ Z ( 4P5 )
Cómo ( 4 P 5 ) es P( P ( P ( P ( 5 ) ) ) )
G 4 5 ≡ Z ( P ( P ( P ( P ( 5 ) ) ) ) )
G 4 5 ≡ Z ( P ( P ( P ( 4 ) ) ) )
Ejemplos: Como P ( 3 ) es 2 entonces

G 5 4 ≡ Z ( P ( P ( P ( 2 ) ) ) )
• Evaluar a >= b cuando a es 5 y b es 4 Como P ( 2 ) es 1 entonces
G 5 4 ≡ Z ( P ( P ( 1 ) ) )
G 5 4 ≡ ( 𝜆xy. Z ( xPy ) ) 5 4 Como P ( 1 ) es 0 entonces
Remplazar 5 en x G 5 4 ≡ Z ( P ( 0 ) )
G 5 4 ≡ [ 5 / x ] ( 𝜆xy. Z ( xPy ) ) 5 4 Como P ( 0 ) es 0 entonces
G 5 4 ≡ ( 𝜆y. Z ( 5Py ) ) 4 G 5 4 ≡ Z ( 0 )
Remplazar 4 en y Z 0 es T entonces
G 5 4 ≡ [ 4 / y ] ( 𝜆y. Z ( 5Py ) ) G 5 4 ≡ T
G 5 4 ≡ Z ( 5P4 )
Como ( 5 P 4 ) es P ( P ( P ( P ( P ( 4 ) ) ) )
G 5 4 ≡ Z ( P ( P ( P ( P ( P ( 4 ) ) ) ) ) )
Como P ( 4 ) es 3 entonces
G 5 4 ≡ Z ( P ( P ( P ( P ( 3 ) ) ) ) )
Ejemplos: G 4 5 ≡ Z ( P ( P ( 3 ) ) )
P ( 3 ) es 2 entonces
• Evaluar a >= b cuando a es 4 y b es 5 G 4 5 ≡ Z ( P( 2 ) )
P ( 2 ) es 1 entonces
G 4 5 ≡ ( 𝜆xy. Z ( xPy ) ) 4 5 G 4 5 ≡ Z ( 1 )
Remplazar 4 en x Z 1 es F entonces
G 4 5 ≡ [ 4 / x ] ( 𝜆xy. Z ( xPy ) ) 5 G 4 5 ≡ F
G 4 5 ≡ ( 𝜆y. Z ( 4Py ) ) 5
Remplazar 5 en y
G 4 5 ≡ [ 5 / y ] ( 𝜆y. Z ( 4Py ) )
G 4 5 ≡ Z ( 4P5 )
Como 4 P 5 es P ( P ( P ( P ( 5 ) ) ) )
G 4 5 ≡ Z ( P ( P ( P ( P ( 5 ) ) ) ) )
G 4 5 ≡ Z ( P ( P ( P ( 4 ) ) ) )
| Cálculo 𝜆 | 3. Condicionales | 3.4. Igualdad y desigualdades | Función igual que |
Función igual que
• Si x >= y , y y >= x entonces x == y. Por lo tanto se define la función E así:
E ≡ ( 𝜆xy. ⋏ ( Z ( xPy ) ) ( Z ( yPx ) ) )
Ejemplos:
• Evaluar a = b cuando a es 4 y b es 4
E 4 4 ≡ ( 𝜆xy. ⋏ ( Z ( xPy ) ) ( Z ( yPx ) ) ) 4 4

Remplazar 4 en x
E 4 4 ≡ [ 4 / x ] ( 𝜆xy. ⋏ ( Z ( xPy ) ) ( Z ( yPx ) ) ) 4
E 4 4 ≡ ( 𝜆y. ⋏ ( Z ( 4Py ) ) ( Z ( yP4 ) ) ) 4
Remplazar 4 en y
E 4 4 ≡ [ 4 / y ] ( 𝜆y. ⋏ ( Z ( 4Py ) ) ( Z ( yP4 ) ) )
E 4 4 ≡ ⋏ ( Z ( 4P4 ) ) ( Z ( 4P4 ) )
Como ( 4P4 ) ≡ 0 y Z ( 0 ) es T entonces
E 4 4 ≡ ⋏ ( T ) ( T )
Como ⋏ ( T ) ( T ) es T entonces
E 4 4 ≡ T
Ejemplos:
• Evaluar a = b cuando a es 4 y b es 5
E 4 5 ≡ ( 𝜆xy. ⋏ ( Z ( xPy ) ) ( Z ( yPx ) ) ) 4 5

Remplazar 4 en x
E 4 5 ≡ [ 4 / x ] ( 𝜆xy. ⋏ ( Z ( xPy ) ) ( Z ( yPx ) ) ) 5
E 4 5 ≡ ( 𝜆y. ⋏ ( Z ( 4Py ) ) ( Z ( yP4 ) ) ) 5
Remplazar 5 en y
E 4 5 ≡ [ 5 / y ] ( 𝜆y. ⋏ ( Z ( 4Py ) ) ( Z ( yP4 ) ) )
E 4 5 ≡ ⋏ ( Z ( 4P5 ) ) ( Z ( 5P4 ) )
Como Z ( 4P5 ) es F
E 4 5 ≡ ⋏ ( F ) ( Z ( 5P4 ) )
Como Z ( 5P4 ) es G 5 4 que es T entonces
E 4 5 ≡ ⋏ ( F ) ( T )
Como ⋏ ( F ) ( T ) es F entonces
E 4 5 ≡ F
| Cálculo 𝜆 | 3. Condicionales | 3.4. Igualdad y desigualdades | Función diferente de |
De igual forma se puede definir otras funciones como x > y, x < y y != y
Función ≠ (Diferente de)
≠ ≡ ¬ ( E x y )
≠ ≡ ( 𝜆xy. ¬ ( E x y ) )
≠ ≡ ( 𝜆xy. ¬ ( ⋏ ( Z( xPy ) ) ( Z( yPx ) ) ) )
Ejemplos:
• Verificar que a ≠ b cuando a es 3 y b es 4
≠ 3 4 ≡ ( 𝜆xy. ¬ ( E x y ) ) 3 4
Remplazando 3 en x
≠ 3 4 ≡ [ 3 / x ] ( 𝜆xy. ¬ ( ( E x y ) ) ) 4
≠ 3 4 ≡ ( 𝜆y. ¬ ( ( E 3 y ) ) ) 4
Remplazando 4 en y
≠ 3 4 ≡ [ 4 / y ] ( 𝜆y. ¬ ( ( E 3 y ) ) )
≠ 3 4 ≡ ¬ ( ( E 3 4 ) )
Como E 3 4 es F entonces
≠ 3 4 ≡ ¬ ( F )
Como ¬ ( F ) es T
≠ 3 4 ≡ T
Ejemplos:
• Verificar el resultado a ≠ b cuando a es 4 y b es 4.
≠ 4 4 ≡ ( 𝜆xy. ¬ ( ( E x y ) ) ) 4 4
Remplazando 4 en x
≠ 4 4 ≡ [ 4 / x ] ( 𝜆xy. ¬ ( ( E x y ) ) ) 4
≠ 4 4 ≡ ( 𝜆y. ¬ ( ( E 4 y ) ) ) 4
Remplazando 4 en y
≠ 4 4 ≡ [ 4 / y ] ( 𝜆y. ¬ ( ( E 4 y ) ) )
≠ 4 4 ≡ ¬ ( ( E 4 4 ) ) )
Como E 4 4 que es T entonces
≠ 4 4 ≡ ¬ ( T )
Como ¬ ( T ) es F entonces
≠ 4 4 ≡ F
| Cálculo 𝜆 | 3. Condicionales | 3.4. Igualdad y desigualdades | Función mayor que |
Función mayor que (>)
• La función mayor qué se define como sigue:
> ≡ ⋏ (G xy) ( ≠ xy )
> ≡ ( 𝜆xy.⋏ ( G x y ) ( ≠ x y ) )
> ≡ ( 𝜆xy.⋏ ( Z( xPy ) ) ( ¬ ( ⋏ ( Z( xPy ) ) ( Z( yPx ) ) ) ) )
Ejemplos:
• Verificar que a > b cuando a es 4 y b es 3
> 4 3 ≡ ( 𝜆xy. ⋏ ( G x y ) ( ≠ x y ) ) 4 3
Remplazando 4 en x
> 4 3 ≡ [ 4 / x ] ( 𝜆xy. ⋏ ( G x y ) ( ≠ x y ) ) 3
> 4 3 ≡ ( 𝜆y. ⋏ ( G 4 y ) ( ≠ 4 y ) ) 3
Remplazando 3 en y
> 4 3 ≡ [ 3 / y ] ( 𝜆y. ⋏ ( G 4 y ) ( ≠ 4 y ) )
> 4 3 ≡ ⋏ ( G 4 3 ) ( ≠ 4 3 )
Como G 4 3 es T entonces
> 4 3 ≡ ⋏ ( T ) ( ≠ 4 3 )
Como ≠ 4 3 es T entonces
> 4 3 ≡ ⋏ ( T ) ( T )
Como ⋏ ( T ) ( T ) es T entonces
> 4 3 ≡ T
Ejemplos:
• Verificar que a > b cuando a es 4 y b es 4
> 4 4 ≡ ( 𝜆xy. ⋏ ( G x y ) ( ≠ x y ) ) 4 4
Remplazando 4 en x
> 4 4 ≡ [ 4 / x ] ( 𝜆xy. ⋏ ( G x y ) ( ≠ x y ) ) 4
> 4 4 ≡ ( 𝜆y. ⋏ ( G 4 y ) ( ≠ 4 y ) ) 4
Remplazando 4 en y
> 4 4 ≡ [ 4 / y ] ( 𝜆y. ⋏ ( G 4 y ) ( ≠ 4 y ) )
> 4 4 ≡ ⋏ ( G 4 4 ) ( ≠ 4 4 )
> 4 4 ≡ ⋏ ( T ) ( ≠ 4 4 )
Como ≠ 4 4 es F entonces
> 4 4 ≡ ⋏ ( T ) ( F )
Como ⋏ ( T ) ( F ) es F entonces
> 4 4 ≡ F
| Cálculo 𝜆 | 3. Condicionales | 3.4. Igualdad y desigualdades | Función menor que |
Función menor que (<)
• La función menor qué se define como sigue:
< ≡ ¬ ( G x y )
< ≡ ( 𝜆xy.¬ ( G x y ) )
< ≡ ( 𝜆xy.¬ ( Z( xPy ) ) )
Ejemplos:
• Evaluar a < b cuando a es igual a 3 y b es igual a 4
< 3 4 ≡ ( 𝜆xy. ¬ ( G x y ) ) 3 4
Remplazar 3 en x
< 3 4 ≡ [ 3 / x ] ( 𝜆xy. ¬ ( G x y ) ) 4
< 3 4 ≡ ( 𝜆y. ¬ ( G 3 y ) ) 4
Remplazar 4 en y
< 3 4 ≡ [4 / y] ( 𝜆y. ¬ ( G 3 y ) )
< 3 4 ≡ ¬ ( G 3 4 )
Como G 3 4 es F entonces
< 3 4 ≡ ¬ ( F )
Como ¬ ( F ) es T entonces
< 3 4 ≡ T
Ejemplos:
• Evaluar a < b cuando a es igual a 4 y b es igual a 3
< 4 3 ≡ ( 𝜆xy.¬ ( G x y ) ) 4 3
Remplazar 4 en x
< 4 3 ≡ [ 4 / x ] ( 𝜆xy. ¬ ( G x y ) ) 3
< 4 3 ≡ ( 𝜆y.¬ ( G 4 y ) ) 3
Remplazar 3 en y
< 4 3 ≡ [ 3 / y] ( 𝜆y. ¬ ( G 4 y ) )
< 4 3 ≡ ¬ ( G 4 3 )
< 4 3 ≡ ¬ ( T )
Como ¬ ( T ) es F entonces
< 4 3 ≡ F
| Cálculo 𝜆 | 3. Condicionales | 3.4. Igualdad y desigualdades | Función menor o igual que |
Función menor o igual que (≤)
• La función menor qué se define como sigue:
≤ ≡ ⋎ ( < x y ) ( E x y )
≤ ≡ ⋎ ( ¬ ( G x y ) ) ( E x y )
≤ ≡ ( 𝜆xy. ⋎ ( < x y ) ( E x y ) )
≤ ≡ ( 𝜆xy. ⋎ ( ¬ ( Z( xPy ) ) ) ( ⋏ ( Z( xPy ) ) ( Z( yPx ) ) )
Ejemplos:
• Evaluar a ≤ b cuando a es igual a 4 y b es igual a 4
≤ 4 4 ≡ ( 𝜆xy. ⋎ ( < x y ) ( E x y ) ) 4 4
Remplazamos 4 en x
≤ 4 4 ≡ [ 4 / x ] ( 𝜆xy. ⋎ ( < x y ) ( E x y ) ) 4
≤ 4 4 ≡ ( 𝜆y. ⋎ ( < 4 y ) ( E 4 y ) ) 4
Remplazamos 4 en y
≤ 4 4 ≡ [ 4 / y ] ( 𝜆y. ⋎ ( < 4 y ) ( E 4 y ) )
≤ 4 4 ≡ ⋎ ( < 4 4 ) ( E 4 4 )
Como < 4 4 es F entonces
≤ 4 4 ≡ ⋎ ( F ) ( E 4 4 )
Como E 4 4 es T entonces
≤ 4 4 ≡ ⋎ ( F ) ( T )
Como ⋎ ( F ) ( T ) es T entonces
≤ 4 4 ≡ T
Ejemplos:
≤ 3 4 ≡ ( 𝜆xy. ⋎ ( < x y ) ( E x y ) ) 3 4
Remplazamos 3 en x
≤ 3 4 ≡ [ 3 / x ] ( 𝜆xy. ⋎ ( < x y ) ( E x y ) ) 4
≤ 3 4 ≡ ( 𝜆y. ⋎ ( < 3 y ) ( E 3 y ) ) 4
Remplazamos 4 en y
≤ 3 4 ≡ [ 4 / y ] ( 𝜆y. ⋎ ( < 3 y ) ( E 3 y ) )
≤ 3 4 ≡ ⋎ ( < 3 4 ) ( E 3 4 )
Como < 3 4 es T entonces
≤ 3 4 ≡ ⋎ ( T ) ( E 3 4 )
Como E 3 4 es F entonces
≤ 3 4 ≡ ⋎ ( T ) ( F )
Como ⋎ ( T ) ( F ) es T entonces
≤ 3 4 ≡ T
Ejemplos:
≤ 5 4 ≡ ( 𝜆xy. ⋎ ( < x y ) ( E x y ) ) 5 4
Remplazamos 5 en x
≤ 5 4 ≡ [ 5 / x ] ( 𝜆xy. ⋎ ( < x y ) ( E x y ) ) 4
≤ 5 4 ≡ ( 𝜆y. ⋎ ( < 5 y ) ( E 5 y ) ) 4
Remplazamos 4 en y
≤ 5 4 ≡ [ 4 / y ] ( 𝜆y. ⋎ ( < 5 y ) ( E 5 y ) )
≤ 5 4 ≡ ⋎ ( < 5 4 ) ( E 5 4 )
Como < 5 4 es F entonces
≤ 5 4 ≡ ⋎ ( F ) ( E 5 4 )
Como (E 5 4) es F entonces
≤ 5 4 ≡ ⋎ ( F ) ( F )
Como ⋎ ( F ) ( F ) es F entonces
≤ 5 4 ≡ F
Contenido
1. Definición
1.2. Sustituciones
2. Aritmética
2.1. Adición
3. Condicionales
4. Recursividad
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 4. Recursividad |
• Sea la función Y ≡ ( 𝜆y. ( 𝜆x. y ( xx ) ) ( 𝜆x. y (xx) ) )
• Una función R (recursiva) aplicada como parámetro a Y (función que define la

recursividad)
YR ≡ ( 𝜆y. ( 𝜆x.y(xx) ) ( 𝜆x.y(xx) ) ) R

YR ≡ [ R / y ] ( 𝜆y. ( 𝜆x.y(xx) ) ( 𝜆x.y(xx) ) )
YR ≡ ( 𝜆x.R(xx) ) ( 𝜆x.R(xx) )
YR ≡ [ ( 𝜆x.R(xx) ) / x ] ( 𝜆x.R(xx) )
YR ≡ R( (𝜆x.R(xx) ) ( 𝜆x.R(xx) ) )
YR ≡ R ( YR )
• Al aplicar R en Y se materializa la recursividad
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 4. Ejemplos | Ejemplos |
Ejemplo 1: YR3 ≡ Z 3 0 ( 3 S ( YR ( P 3 ) ) )
Como en Z 3, 3 es diferente de 0 se tiene que Z 3 ≡ F
entonces
Sea R la función recursiva que calcula la sumatoria de
YR3 ≡ F 0 ( 3 S ( YR ( P 3 ) ) )
i cuando i va desde 0 hasta n ( ∑𝑛𝑖=0 𝑖 ) å la cual se
puede escribir como n + ∑𝑛−1 Falso retorna el segundo parámetro entonces
𝑖=0 𝑖
YR3 ≡ ( 3 S ( YR ( P 3 ) ) )
Como P 3 ≡ 2 entonces
Entonces la función recursiva sería así:
YR3 ≡ 3 S ( YR 2 ) (pendiente por reemplazar)
R ≡ (𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) ) Resolviendo YR 2 se tiene
YR2 ≡ R ( YR ) 2
Si queremos calcular ( ∑𝑛𝑖=0 𝑖 ) cuando n = 3 Remplazamos la primera R por su función 𝜆
tendríamos YR2 ≡ 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) ( YR ) 2
YR3 Remplazamos r por YR
Pero YR es R( YR ) YR2 ≡ [ YR / r ] 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) 2
YR3 ≡ R( YR ) 3 YR2 ≡ 𝜆n. Z n 0 ( n S ( YR ( P n ) ) ) 2
Remplazamos la primera R por su función 𝜆 Remplazamos n por 2
YR3 ≡ 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) (YR) 3 YR2 ≡ [ 2 / n ] 𝜆n. Z n 0 ( n S ( YR ( P n ) ) )
Remplazamos YR por r YR2 ≡ Z 2 0 ( 2 S ( YR( P 2 ) ) )
YR3 ≡ [ YR / r ] 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) 3 … (continua)
YR3 ≡ 𝜆n. Z n 0 ( n S ( YR ( P n ) ) ) 3
Remplazamos 3 por n
YR3 ≡ [ 3 / n ] 𝜆n. Z n 0 ( n S ( Y R ( P n ) ) )
4. Recursividad
Ejemplo 1: (continuación) Como en Z 1, 1 es diferente de 0, se tiene que Z 1 ≡ F

YR1 ≡ F 0 ( 1 S ( YR ( P 1 ) ) )
Falso retorna el segundo parámetro entonces
Como en Z 2, 2 es diferente de 0, se tiene que Z 2 ≡ F,
entonces YR1 ≡ 1 S ( YR ( P 1 ) )
YR2 ≡ F 0 ( 2 S ( YR( P 2 ) ) ) Como P1 ≡ 0, entonces
Falso retorna el segundo parámetro entonces YR1 ≡ 1 S ( YR0 ) (pendiente por reemplazar)
YR2 ≡ 2 S ( YR( P 2 ) ) Resolviendo YR0 se tiene
Como P2 ≡ 1, entonces YR0 ≡ R ( YR ) 0
YR2 ≡ 2 S ( YR1 ) (pendiente por reemplazar) Remplazamos la primera R por su función 𝜆
Resolviendo YR1 se tiene YR0 ≡ 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) ( YR ) 0
YR1 ≡ R( YR ) 1 Remplazamos YR por r
Remplazamos la primera R por su función 𝜆 YR0 ≡ [ YR / r ] 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) 0
YR1 ≡ 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) (YR) 1 YR0 ≡ 𝜆n. Z n 0 ( n S ( YR ( P n ) ) ) 0
Remplazamos YR por r Remplazamos 0 por n
YR1 ≡ [ YR / r ] 𝜆rn. Z n 0 ( n S ( r ( P n ) ) ) 1 YR0 ≡ [ 0 / n ] 𝜆n. Z n 0 ( n S ( YR ( P n ) ) )
YR1 ≡ 𝜆n. Z n 0 ( n S ( YR( P n ) ) ) 1 YR0 ≡ Z 0 0 ( 0 S ( YR ( P 0 ) ) )
Remplazamos 1 por n Como en Z 0, 0 es igual a 0 se tiene que: Z 0 ≡ T
YR1 ≡ [ 1 / n ] 𝜆n. Z n 0 ( n S ( YR ( P n ) ) ) YR0 ≡ T 0 ( 0 S ( YR( P 0 ) ) )
YR1 ≡ Z 1 0 ( 1 S ( YR( P 1 ) ) ) … (continua)
4. Recursividad
Ejemplo 1: (continuación)
Verdadero retorna el primer parámetro entonces

YR0 ≡ 0
Se remplaza YR0 en YR1 así:
YR1 ≡ 1 S ( YR0 )
YR1 ≡ 1 S ( 0 )
YR1 ≡ 1
YR2 ≡ 2 S ( YR1 )
YR2 ≡ 2 S ( 1 )
YR2 ≡ 3
YR3 ≡ 3 S ( 3 )
YR3 ≡ 6 ≡ ∑%123 𝑖 = 6
4. Recursividad
Ejemplo 2: YR4 ≡ Z 4 1 ( M 4 YR ( P 4 ) )
Si se quiere programar la función factorial se parte de Como en Z 4, 4 es diferente de 0, se tiene que Z 4 ≡ F
lo siguiente: YR4 ≡ F 1 ( M 4 YR( P 4 ) )
F(x) = x * F( x -1 ) Falso retorna el segundo parámetro entonces
Sea M la función multiplicación YR4 ≡ M 4 YR( P 4 )
M ≡ ( 𝜆xyz.x( yz ) ) Como P 4 ≡ 3, entonces
Se podría definir la función R así: YR4 ≡ M 4 YR3 (pendiente por reemplazar)
Resolviendo YR3 tenemos
R ≡ (𝜆rn. Z n 1 ( M n r( P n ) ) ) YR es R( YR )
YR3 ≡ R( YR ) 3
Si queremos calcular el factorial de n cuando n = 4 Remplazamos la primera R por su formula 𝜆
tendríamos lo siguiente: YR3 ≡ 𝜆rn. Z n 1 ( M n r( Pn ) ) (YR) 3
YR4 Remplazamos YR por r.
YR es R ( YR ) YR3 ≡ [ YR / r ] 𝜆rn. Z n 1 ( M n r( Pn ) ) 3
YR4 ≡ R ( YR ) 4 YR3 ≡ 𝜆n. Z n 1 ( M n YR ( P n ) ) 3
Remplazamos la primera R por su función 𝜆 Remplazamos 3 por n
YR4 ≡ 𝜆rn. Z n 1 ( M n r ( P n ) ) ( YR ) 4 YR3 ≡ [ 3 / n ] 𝜆n. Z n 1 ( M n YR( P n ) )
Remplazamos YR por r YR3 ≡ Z 3 1 ( M 3 YR( P 3 ) )
YR4 ≡ [ YR / r ] 𝜆rn. Z n 1 ( M n r ( P n ) ) 4 … (continua)
YR4 ≡ 𝜆n. Z n 1 ( M n YR ( P n ) ) 4
Remplazamos 4 por n
YR4 ≡ [ 4 / n ] 𝜆n. Z n 1 ( M n YR ( P n ) )
4. Recursividad
| Cálculo 𝜆 | 3. Condicionales | 4. Recursividad | Ejemplos |
Ejemplo 2: (Continuación) Como en Z 2, 2 es diferente de 0, se tiene que Z 2 ≡ F

YR2 ≡ F 1 ( M 2 YR( P 2 ) )
Como en Z 3, es diferente de 0, se tiene que Z 3 ≡ F, Falso retorna el segundo parámetro entonces
entonces YR2 ≡ M 2 YR( P 2 )
YR3 ≡ F 1 ( M 3 YR( P 3 ) ) Como P 2 ≡ 1, entonces
Falso retorna el segundo parámetro entonces YR2 ≡ M 2 YR1 (pendiente por reemplazar)
YR3 ≡ M 3 YR( P 3 ) Resolviendo YR1 tenemos
Como P 3 ≡ 2, entonces YR es R ( YR )
YR3 ≡ M 3 YR2 (pendiente por reemplazar) YR1 ≡ R ( YR ) 1
Resolviendo YR2 tenemos Remplazamos la primera R por su función 𝜆
YR es R ( YR ) YR1 ≡ 𝜆rn. Z n 1 ( M n r ( P n ) ) ( YR ) 1
YR2 ≡ R ( YR ) 2 Remplazamos YR por r
Remplazamos la primera R por su función 𝜆 YR1 ≡ [ YR / r ] 𝜆rn. Z n 1 ( M n r ( P n ) ) 1
YR2 ≡ 𝜆rn. Z n 1 ( M n r ( P n ) ) ( YR ) 2 YR1 ≡ 𝜆n. Z n 1 ( M n YR ( P n ) ) 1
Remplazamos YR por r … (continua)
YR2 ≡ [ YR / r ] 𝜆rn. Z n 1 ( M n r ( P n ) ) 2
YR2 ≡ 𝜆n. Z n 1 ( M n YR ( P n ) ) 2
Remplazamos 2 por n
YR2 ≡ [ 2 / n ] 𝜆n. Z n 1 ( M n YR ( P n ) )
YR2 ≡ Z 2 1 ( M 2 YR ( P 2 ) )
4. Recursividad
Ejemplo 2: (Continuación)
Remplazamos 0 por n
Remplazamos 1 por n YR0 ≡ [ 0 / n ] 𝜆n. Z n 1 ( M n YR ( P n ) )
YR1 ≡ [ 1 / n ] 𝜆n. Z n 1 ( M n YR ( P n ) ) YR0 ≡ Z 0 1 ( M 0 YR ( P 0 ) )
YR1 ≡ Z 1 1 ( M 1 YR ( P 1 ) ) Como Z 0 ≡ T entonces
Como en Z 1, 1 es diferente de 0, se tiene que Z 1 ≡ F, YR0 ≡ T 1 ( M 0 YR ( P 0 ) )
entonces Como verdadero retorna el primer parámetro,
YR1 ≡ F 1 ( M 1 YR ( P 1 ) ) entonces
Falso retorna el segundo parámetro entonces YR0 ≡ 1
YR1 ≡ M 1 YR ( P 1 ) Remplazando YR0 en YR1 tenemos:
Como P 1 ≡ 0, entonces YR1 ≡ M 1 YR(0)
YR1 ≡ M 1 YR0 (pendiente por reemplazar) YR1 ≡ M 1 1
Resolviendo YR0 tenemos que: YR1 ≡ 1
YR es R( YR ) Remplazando YR1 en YR2 tenemos:
YR0 ≡ R( YR ) 0 YR2 ≡ M 2 YR ( 1 )
Remplazamos la primera R por su función 𝜆 YR2 ≡ M 2 1
YR0 ≡ 𝜆rn. Z n 1 ( M n r ( Pn ) ) ( YR ) 0 YR2 ≡ 2
Remplazamos YR por r … (continua)
YR0 ≡ [ YR / r ] 𝜆rn. Z n 1 ( M n r( Pn ) ) 0
YR0 = 𝜆n. Z n 1 ( M n YR ( P n ) ) 0
4. Recursividad
Ejemplo 2:(Continuación)
• Remplazando YR2 en YR3 tenemos:

• YR3 ≡ M 3 YR ( 2 )
• YR3 ≡ M 3 2
• YR3 ≡ 6
• Remplazando YR3 en YR4 tenemos:
• YR4 ≡ M 4 YR ( 3 )
• YR4 ≡ M 4 6
• YR4 ≡ 24
• Entonces Factorial n cuando n = 4 es igual a 24
GRACIAS

Presentación - Cálculo Lambda - V4 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Presentación - Cálculo Lambda - V4 PDF

Cargado por

Copyright:

Formatos disponibles

Cálculo

• El cálculo λ puede ser llamado el lenguaje de programación universal más

• El cálculo λ consiste en:

• El cálculo λ es universal en el sentido de que cualquier función computable

• El cálculo λ es, equivalente a las máquinas de Turing.

• El cálculo λ tiene un enfoque más relacionado con el software que con el

• El concepto central en el cálculo λ es la "expresión”.

• Un "nombre” o "variable", es un identificador que puede ser cualquiera de las

• Una expresión se define recursivamente como sigue:

<expression> := <name> | <function> | <application>

• Con el fin de evitar el desorden de las expresiones con paréntesis, se adopta la

◦ 𝐸# 𝐸$ 𝐸% … 𝐸' es equivalente a (… ((𝐸# 𝐸$ )𝐸% ) … 𝐸' )

• Como puede verse por la definición de las expresiones λ dadas anteriormente,

• Un ejemplo de una función es el siguiente:

• Esta expresión define la función de identidad.

• El nombre después de λ “x” es el identificador del argumento de esta función.

• Las funciones se pueden aplicar en las expresiones, a esto se le denomina una

• Esta es la función identidad aplicada a y.

• Los paréntesis se utilizan para mayor claridad a fin de evitar la ambigüedad.

• Las aplicaciones de la función se evalúan sustituyendo el valor del argumento

• Los nombres de los argumentos en las definiciones de funciones no tienen

• Los nombres son sólo "marcador de posición”.

• Se utilizan para indicar cómo reorganizar los argumentos de la función

(λz.z) ≡ (λy.y) ≡ (λt.t) ≡ (λu.u) ... Etc.

• En el cálculo λ todos los nombres son locales a las definiciones.

• En la función λx.x decimos que x está "unido” (enlazado) ya que su ocurrencia

• Un nombre no precedido por un λ se llama una "variable libre”.

• En la expresión (λx.xy) la variable x está enlazada y y está libre.

◦ La y en el cuerpo de la segunda expresión está enlazada a la segunda λ y

◦ Es muy importante notar que la x en la segunda expresión es totalmente

• Formalmente decimos que una variable está libre en una expresión si se

1. <nombre> está libre en <nombre>.

2. <nombre> está libre en λ <nombre1>. <exp> si el identificador <nombre>

3. <nombre> está libre en E1 E2 si <nombre> está libre en E1 o si está libre

• Una variable está enlazada si uno de dos casos se cumple:

1. <nombre> está enlazado en λ <nombre1>. <exp> si el identificador

2. <nombre> está enlazado en E1 E2 si <nombre> está enlazado en E1 o si

• Debe enfatizarse que el mismo identificador puede estar libre y enlazado en

◦ En la primera subexpresión entre paréntesis, el primer y está libre, pero

• Posiblemente el hecho mas confuso al abordar el estudio del cálculo λ por

• Para simplificar la notación, sin embargo, es posible usar mayúsculas, dígitos

• La función de identidad, por ejemplo, se puede denotar con I que es un alias

• Por ejemplo la función de identidad aplicada a sí misma corresponde a lo

• En esta expresión la primera x en el cuerpo de la primera expresión entre

• La función de identidad aplicada a sí misma

• Realizando la sustitución se produce lo siguiente

◦ [λz.z / x] x = λz.z ≡ I, es decir, la función de identidad de nuevo.

• Debemos tener cuidado al realizar sustituciones para evitar mezclar las

• La función a la izquierda contiene una y enlazada, mientras que la y a la

• Simplemente cambiando el nombre de y a t obtenemos lo siguiente:

◦ ( λx. ( λt.xt ) ) y = ( λt.yt ), que es un resultado completamente diferente

• Por lo tanto, si la función λx. <exp> se aplica a E, sustituimos todas las

• Por ejemplo, en la expresión siguiente sólo debemos asociar el argumento x

( λx.( λy.( x ( λx.xy ) ) ) ) y

• Antes de realizar la asociación de argumentos, es necesario cambiar variables

( λx.( λy.( x ( λx.xy ) ) ) ) y ≡ ( λx.( λt.( x ( λx.xt ) ) ) ) y

( λx.( λt.( x ( λx.xt ) ) ) ) y

◦ Continuando con la sustitución el procedimiento queda así:

[y/x]( λx.( λt.( x ( λx.xt ) ) ) )

• En la reducción de orden normal tratamos de reducir siempre la expresión

• Se deber continuar hasta que no se produzcan reducciones adicionales.

• Los números se pueden representar en el cálculo λ a partir de cero y escribir

• En el cálculo λ sólo podemos definir nuevas funciones, por lo tanto los