Cálculo-λ

Antonio Almazán Faura

Lidia Quintana Pancorbo
Índice
Cálculo- λ
Sintaxis
Notación: paréntesis y macros
Conversiones
Igualdades
Ejemplos: lógica booleana y aritmética
Conclusiones

Cálculo-λ 2
Cálculo-λ
Autor: Alonzo Church
Objetivo:
„ Formalizar el modo de escribir funciones.
„ A partir del concepto de función-λ será
posible generar cualquier función
computable.

Cálculo-λ 3
Cálculo-λ
Método:
„ Generar funciones que tomarán datos de
entrada de un problema y proporcionarán
datos de salida.
„ Todo sin salirse de la definición de este
lenguaje, de su estructura y sintaxis.
Este nueva notación derivó en distintos
lenguajes de programación (como LISP)

Cálculo-λ 4
Sintaxis
Clases de
expresiones-λ <exp-λ>
„ Variables ::= <variable>
„ Aplicación de ::= <exp-λ> <exp-λ>
función
„ Abstracción con ::= λ<variable>.<exp-λ>
variable ligada y
cuerpo de función

Cálculo-λ 5
Sintaxis
Ejemplos
„ Aplicación de función: E1 E2
representa el resultado de
x(y)
aplicar la función E1 sobre la
función E2 m(n(y))
„ Abstracción: representa el λV.E
resultado de evaluar E donde λx.x
la variable V tomará el valor
al que se ligue por λab.(a(b))
argumentos
Cálculo-λ 6
Sintaxis
Variables ligadas Valor de Valor de
dentro del cuerpo argumento1 argumento2

(λxy. x(λab.a)y) (λcd.c) (λef.e)

Cuerpo de función

Si observamos ambos argumentos, son iguales excepto

por el renombramiento. ES NECESARIO RENOMBRAR,
para no confundirnos al realizar las vinculaciones y
sustituciones.

Cálculo-λ 7
Sintaxis
Expresión-λ de partida
(λxy. x(λab.a)y) (λcd.c) (λef.e)
Expresión-λ de resultado parcial
(λcd.c) ( λab.a ) (λef.e)
Expresión-λ de resultado final
λab.a
Todo son EXPRESIONES-λ, y sólo intervienen
“letras”, paréntesis y puntos.
Cálculo-λ 8
Notación
Una expresión-λ “auténtica”

„ SIEMPRE contiene TODOS los PARENTESIS

„ NUNCA contiene MACROS

Pero por comodidad, admitimos una

notación que omite paréntesis y emplea
macros.

Cálculo-λ 9
Notación: paréntesis
Al omitir paréntesis debemos tener en
cuenta:
1) Asociación
E1 E2 E3 ... En ≡ (...((E1 E2)E3)...En)
2) Ámbito de variable
λV. E1 E2 E3...En ≡ λV.(E1 E2 E3...En)
3) Orden de variable
λV1 V2 V3... Vn ≡ λV1(λV2(...(λVn.E)...))
La aparición de una variable V en una
expresión-λ es libre si no aparece en el
alcance de λV
Cálculo-λ 10
Notación: macros
Admitimos macros por una cuestión de
comprensión y comodidad al operar,
pero no forman parte del cálculo-λ
Ejemplo
macro: muchasX = xxxxxxxxxx
uso: (λx.muchasX) (a)
resultado: aaaaaaaaaa

Cálculo-λ 11
Conversiones
El cálculo-λ está formado por:
„ Una SINTAXIS específica

„ Unas CONVERSIONES (o reducciones)

entre expresiones

Cualquier conversión se puede efectuar,

si las sustituciones son válidas

Cálculo-λ 12
Conversiones
Una sustitución E[V:=E’] es válida sii ninguna
de las variables libre de E’ se convierte en
una variable ligada en E[V:=E’]

α-redex: renombramiento de variables

β-redex: vinculaciones de variables
(“bindings”)
η-redex: dos funciones son iguales si al
aplicarles los mismos argumentos dan los
mismos resultados

Cálculo-λ 13
Conversiones
Las reglas de conversión son las que nos van
a permitir “jugar” con las expresiones-λ

La reducción-α es “intuitiva” y nos ayuda a

manipular las expresiones; y la reducción-η
puede ser necesaria, aunque nosotros no la
vamos a ver en los ejemplos.

Por otro lado, la reducción-β es la más

importante.

Cálculo-λ 14
Conversiones
α-redex [sustitución]

λV.E α λV’.E [V:=V’]

β-redex [binding]
β
(λV.E1) E2 E1 [V:=E2]

Cálculo-λ 15
Conversiones
Ejemplo de α-redex [sustitución]
λV.E α λV’.E [V:=V’]

α
(λx.x) Æ x=y (λy.y)
(λxy.xy) Æ x=a, y=b α (λab.ab)
(λxy.xy) Æ x=a α (λay.ay)

Cálculo-λ 16
Conversiones
Ejemplo de β-redex [binding]
(λV.E1) E2 β E1 [V:=E2]

(λx.x) (a) β a
(λxy.xy) (a) (b) β ab
(λxy.xy) (b) β λy.by

Cálculo-λ 17
Igualdades
Dos expresiones-λ, E y E’, son iguales sii:
1. Son idénticas
2. Existe una cadena de expresiones E1E2...En
tal que:
a) E = E1
b) E’ = En
c) Para cada Ei existe una conversión a Ei+1 y
viceversa

Cálculo-λ 18
Cálculo-λ : EJEMPLOS
Con las herramientas que tenemos (sintaxis y
reducciones) intentaremos demostrar que el
álgebra booleana y la aritmética son
computables.
Para estos ejemplos, primero propondremos
un conjunto de funciones, y luego veremos
que actúan como deben según las
propiedades que se esperan de ellos.

Cálculo-λ 19
Lógica
Para empezar vamos a definir:
λxy.x = true
λxy.y = flase
λt.t (λxy.y) (λxy.x)
= λt.t true false = not
Para comprender mejor de que hablamos, les
asignaremos macros, con las que trabajar
cómodamente

Cálculo-λ 20
Lógica
Ahora con un ejemplo vamos a probar
que estas definiciones en expresiones
lambda se comportan realmente como
los operadores lógicos que decimos que
son.

Cálculo-λ 21
Lógica: Ejercicio 1
Probar que not true = false
( λt.t false true ) true
( λt.t (λab.b) (λcd.c)) (λxy.x) * binding: t = (λxy.x)
(λxy.x) (λab.b) (λcd.c) * true false true
λy.(λab.b) (λcd.c) binding: x = (λab.b)

(λab.b) = false * binding: y = (λcd.c)

Ahora sustituiríamos y en el
cuerpo de la función, pero no
aparece en él
Cálculo-λ 22
Lógica
Ahora definimos otras dos funciones
lógicas
and = λxy.x y (λxy.y) = λxy.x y false
or = λxy.x (λxy.x) y = λxy.x true y
Con true, false, not, and y or vamos
a intentar probar que tenemos toda la
lógica.

Cálculo-λ 23
Lógica: Ejercicio 2
Probar que and true false = false
(λxy.xy false) (true) (false)
binding: x = true
binding: y = false
true false false
sustituimos la macro true
(λxy.x) (false) (false)
x unifica con false; devuelve false
Cálculo-λ 24
Lógica: Ejercicio 3
Probar que or true false = true
(λxy.x true y) true true
(λxy.x (λab.a) y) (λcd.c) (λef.e)
binding: x = (λcd.c)
binding: y = (λef.e)
(λcd.c) (λab.a) (λef.e)
binding: c = (λab.a)
binding: d = (λef.e)
(λab.a) = true
Cálculo-λ 25
Lógica: Selecciones
Otra propiedad de las funciones true y false:
funcionan como operadores de selección:
E Æ E1 | E2
donde E representa true o false
true E1 E2 = E1
true selecciona el primer arguemento
false E1 E2 = E2
false selecciona el primer arguemento
Cálculo-λ 26
Lógica: Conclusiones
Derivado de los ejemplos, comprobamos que
podemos construir todas las tablas de la
verdad con las macros: true, false, not, and
y or.
Con las macros true y false además
tenemos operadores que nos permiten la
generación de IF-THEN-ELSE.

LA LÓGICA BOOLEANA ES COMPUTABLE

Cálculo-λ 27
Aritmética
Alguna definiciones:
0 = λfx.x
1 = λfx.fx
2 = λfx.f(fx) = λfx.f2x ...
suc = λnfx.nf(fx)
add = λmnfx.mf(nfx)
iszero = λn.n(λx.(λab.b)) (λcd.c)
= λn.n(λx.false) true
Por comodidad vamos a asignarles macros

Cálculo-λ 28
Aritmética
Ahora vamos a probar que estas
definiciones de funciones conocidas en
expresiones lambda se comportan
realmente como esperamos de ellas

Cálculo-λ 29
Aritmética: Ejercicio 1
Probar que iszero 0 = true
(λn.n(λx.false) true ) (λga.a)
binding: n = λga.a
λga.a (λx.false) (true)
binding: g = (λx.false )
binding: a = true
true

Cálculo-λ 30
Aritmética: Ejercicio 2
Probar que iszero 1 = false
(λn.n(λx.false)true) (λga.ga)
binding: n = λga.ga
λga.ga (λx.false) (true)
binding: g = (λx.false)
binding: a = true
(λx.false) true ≡ (λx.(λab.b)) true
binding: x = true = (λab.b)
x no aparece en el cuerpo de la función, así
devolvemos la macro false
Cálculo-λ 31
Aritmética: Ejercicio 3
Probar que suc 1 = 2
(λnfx.nf(fx)) (λga.ga )
binding: n = 1
las variables que no ligadas se dejan tal cual están

λfx.( (λga.ga) f (fx) )

binding: g = f
binding: a = (fx)

λfx.f(fx) =2
Cálculo-λ 32
Aritmética: Ejercicio 4
Probar que add 1 2 = 3
λmnfx.mf(nfx) (1) (2)
binding: m = 1
binding: n = 2
λfx.1f(2fx) ≡ λfx.( (λga.ga) f (2fx))
binding: g = f
binding: a = (2fx)
λfx.f(2fx) ≡ λfx.f(λhe.h(he) (f) (x))
binding: h = f
binding: e = x
λfx.f(f(fx)) = λfx.f3x = 3
Cálculo-λ 33
Aritmética: Bucles
Ejemplo: 3 not false
(λfx.fffx) not false
not(not(not(false)))
not(not(true))
(not(false))
true
Como vemos el efecto de los números puede
ser considerado en ocasiones como un FOR
finito, en este caso sobre la función not
Cálculo-λ 34
Aritmética: Bucles
Tenemos todo lo necesario para
“programar”
„ Condicionales, bucles finitos, lógica y
aritmética
Sin embargo, hay funciones que
precisan de bucles WHILE.
Aquello que se pueda programar con un
while también se puede programar
mediante RECURSIÓN.
Cálculo-λ 35
Aritmética: Recursividad
Vamos a centrarnos en la recursión y
poner un ejemplo para verificar que
también tiene un lugar en el cálculo-λ

El ejemplo que vamos a tratar es la

multiplicación: vamos a ver una
definición recursiva de multiplicación

Cálculo-λ 36
Aritmética: Recursividad
Definición recursiva de mult
mult =
λmn.((iszero m) 0 (add n (mult (pre m) n)))
Sin embargo no es válida porque en la
definición utilizamos la propia expresión
mult
Además necesitamos poder escribir
toda la expresión sin macros

Cálculo-λ 37
Artimética: Recursividad
Para redefinir la multiplicación nos
servimos del concepto de punto fijo
FuncionA (argA) = argA
FPF (FuncionA) = argA
Ejemplos:

Función: λx.x Función: λfx.x

FPF(λx.x) = λa.a FPF(λfx.x) = λa.a
λx.x (λa.a) = λa.a λfx.x (λa.a) =λfa.a
Cálculo-λ 38
Aritmética: Recursividad
Existe una función que obtiene UN
punto fijo de cualquier otra función:
Y= λf .(λx.f(xx)) (λx.f(xx))
Este operador aplicado a una función
nos ofrece un punto fijo para dicha
función.
Es decir: E (YE) = YE

Cálculo-λ 39
Artimética: Recursividad
Redefinimos la operación de multiplicación:

multFn =λfmn.((iszero m) 0 (add n (f (pre m) n)))

El punto fijo de esta función es la

multiplicación!
Y multFn = mult

Ahora ambas expresiones se pueden

poner como expresiones lambda,
sustituyendo todas las macros
Cálculo-λ 40
Artimética: Recursividad
Recapitulamos
1) No podemos definir mult sobre sí misma
2) Definimos una nueva función multFn que admite
un argumento más que la primera (que
representará una función a ejecutar)
3) Calculamos el punto fijo de multFn mediante Y, y
obtenemos “mágicamente” que es mult.
Y multFn = mult FPF (FuncionA) = argA

4) Así se cumple que si añadimos dos parámetros más

multFn mult m n = mult m n FuncionA (argA) = argA

Cálculo-λ 41
Aritmética: Recursividad
Comprobemos que hemos encontrado la
multiplicación:
Hipótesis: multFn mult = mult
Veamos: multFn mult 2 3 = mult 2 3

λfmn.((iszero m) 0 (add n (f (pre m) n)))

mult 2 3
((iszero 2) 0 (add 3 (mult (pre 2) 3)))
add 3 (mult (pre 2) 3)

Cálculo-λ 42
Aritmética: Recursividad
multFn mult
add 3 (mult (pre 2) 3) = mult
add 3 (multFn mult (pre 2) 3)

add 3 (λfmn.((iszero m)
0 (add n (f (pre m) n)) mult 1 3)
add 3 ((iszero 1)
0 (add 3 (mult (pre 1) 3)))

add 3 (add 3 (mult (pre 1) 3))

Cálculo-λ 43
Aritmética: Recursividad
multFn mult
add 3 (add 3 (mult (pre 1) 3)) = mult

add 3 (add 3 (multFn mult (pre 1 ) 3) )

add 3 (add 3 (λfmn.((iszero m)

0 (add n (f (pre m) n)) ) mult 0 3))
add 3 (add 3 ((iszero 0)
0 (add 3 (mult (pre 0) 3))) )

add 3 (add 3 0) = 6
Cálculo-λ 44
Aritmética: Conclusiones
Tenemos definiciones de funciones-λ para
todos los números.
Tenemos definiciones de macros para
calcular: sucesor, suma, multiplicar, etc.
Además, los números nos permiten la
generación de bucles finitos (for)
Y, por último, tenemos posibilidades de hacer
funciones recursivas mediante las funciones
de punto fijo
LA ARITMÉTICA ES COMPUTABLE
Cálculo-λ 45
Conclusiones
La terminología de Church y funciones-λ
nos permite:
„ Realizar operaciones lógicas
„ Realizar operaciones matemáticas
„ Realizar selecciones (if-then-else)
„ Realizar bucles limitados (for-acotados)
„ Realizar bucles ilimitados (while) o lo que
es lo mismo: funciones recursivas

Cálculo-λ 46
Conclusiones
Hemos creado funciones-λ que hacen lo
mismo que cualquier programa de
ordenador.
Luego parece razonable la pretensión
de Church de que cualquier cosa
computable puede ponerse en forma de
una expresión-λ (y viceversa)

Cálculo-λ 47