Facultad de Ciencias de la Computación Cálculo Lambda Reducción β Transformación:Gelfond-Lifchitz Dr. Fernando Zacarías Flores Primavera 2014
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-λ 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-λ 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)
Sintaxis Clases de expresiones-λ Variables Aplicación de función Abstracción con variable ligada y cuerpo de función <exp-λ> ::= <variable> ::= <exp-λ> <exp-λ> ::= λ<variable>.<exp-λ>
Sintaxis Ejemplos Aplicación de función: representa el resultado de aplicar la función E1 sobre la función E2 Abstracción: representa el resultado de evaluar E donde la variable V tomará el valor al que se ligue por argumentos E1 E2 x(y) m(n(y)) λv.e λx.x λab.(a(b))
Sintaxis Variables ligadas dentro del cuerpo Valor de argumento1 Valor de 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.
Sintaxis Expresión-λ de partida (λxy. x(λab.a)y) (λcd.c) Expresión-λ de resultado parcial (λcd.c) ( λab.a ) (λef.e) Expresión-λ de resultado final λab.a (λef.e) Todo son EXPRESIONES-λ, y sólo intervienen letras, paréntesis y puntos.
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.
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
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: uso: resultado: muchasx = xxxxxxxxxx (λx.muchasx) (a) aaaaaaaaaa
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
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
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 vamosa veren losejemplos. Por otro lado, la reducción-β es la más importante.
Conversiones α-redex [sustitución] α λv.e λv.e [V:=V ] β-redex [binding] β (λv.e1) E2 E1 [V:=E2]
Conversiones Ejemplo de α-redex λv.e α λv.e [V:=V ] [sustitución] (λx.x) x=y (λxy.xy) x=a, y=b (λxy.xy) x=a α α α (λy.y) (λab.ab) (λay.ay)
Conversiones Ejemplo de β-redex [binding] β (λv.e1) E2 E1 [V:=E2] (λx.x) (a) (λxy.xy) (a) (b) (λxy.xy) (b) β β β a ab λy.by
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-λ : 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.
Lógica Para empezar vamos a definir: λxy.x λxy.y = true = 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
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.
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 (λxy.x) (λab.b) (λcd.c) λy.(λab.b) (λcd.c) (λab.b) = false * true false true binding: x = (λab.b) * binding: y = (λcd.c) Ahora sustituiríamos y en el cuerpo de la función, pero no aparece en él
Lógica Ahora definimos otras dos funciones lógicas and = or = λxy.x y (λxy.y) λxy.x (λxy.x) y = λxy.x y false = λxy.x true y Con true, false, not, and y or vamos a intentar probar que tenemos toda la lógica.
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
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
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
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
Aritmética Alguna definiciones: 0 = 1 = 2 = suc = add = λfx.x λfx.fx λfx.f(fx) = λfx.f 2 x... λnfx.nf(fx) λmnfx.mf(nfx) λn.n(λx.(λab.b)) (λcd.c) iszero = = λn.n(λx.false) true Por comodidad vamos a asignarles macros
Aritmética Ahora vamos a probar que estas definiciones de funciones conocidas en expresiones lambda se comportan realmente como esperamos de ellas
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
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 binding: x = true = (λab.b) (λx.(λab.b)) true x no aparece en el cuerpo de la función, así devolvemos la macro false
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á λfx.( (λga.ga) f (fx) ) binding: g = f binding: a = (fx) λfx.f(fx) = 2
λfx.f(f(fx)) = λfx.f 3 x = 3 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
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
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.
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
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
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 FPF(λx.x) = λa.a λx.x (λa.a) = λa.a Función: λfx.x FPF(λfx.x) =λa.a λfx.x (λa.a) =λfa.a
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
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
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
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)
Aritmética: Recursividad add 3 (mult (pre 2) 3) add 3 (multfn mult (pre 2) 3) multfn mult = mult 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))
Aritmética: Recursividad add 3 (add 3 (mult (pre 1) 3)) multfn mult = 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
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
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
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)
Reducción
Transformación de Gelfond & Lifschitz F* = F si F es atomica (F G)* = F* G* (F G)* = F* G* si X F ( F)* = Т en otro caso (H B)* = H* B* P* = { (H B)* H B P }
Ejercicios 1.- Sea P: a a. b c b. 2.- Sea P: a a. 4.- Sea P: a b. b a. p p. p a. 3.- Sea P: a b. b a. 5.- Sea P: b a.
Soluciones 1.- {a} es un answer set de P 2.- No tiene answer sets 3.- {a} y {b} es un answer set de P 4.- {a, p} es un answer set de P 5.- { } es una answer set de P
Fundamentos de Lenguajes de Programación Lambda. LCI y Lisp 1.- Defina una función en LISP que convierta un número menor que 100, de formato árabe a formato romano, teniendo en cuenta que: a) El valor de cada letra romana con la numeración árabe es la siguiente: I=1 V=5 X=10 L=50 C=100 b) En numeración romana no puede aparecer más de tres caracteres seguidos iguales, es decir, el número IIII es imposible. c) Al poner a la izquierda de un número el inmediatamente anterior se resta a aquél el valor de éste. Por ejemplo, IV, es (5 1 = 4) La función se llamará a-romano y tendrá como único argumento un número entero en notación árabe; devuelve como resultado ese número en notación romana contenido en una lista. Ejem. 1- (a-romano 89) (L X X X IX) 2- (a-romano 19) (X IX) 3- (a-romano 120) (CASO NO CONTEMPLADO) 2.- Definir la función en LISP que halle el máximo común divisor de 2 números Ejem. (mcd 42 56) 14 3.- Definir función en LCI que cuenta la cantidad de veces que aparece un elemento en una lista en todos sus niveles. Ejem. Cuenta 2 1..5:1..5:1..5:2:Nil la lista que se le da, es: [[\y.y, 2, 3, 4, 5], [\y.y, 2, 3, 4, 5], [\y.y, 2, 3, 4, 5], 2] el resultado es: 4 (el 2 aparece 4 veces) 4.- Definir función en LCI que ordene los números de una lista Ejem. Ordena 3:2:5:Nil [2, 3, 5] 5.- Cuáles de las siguientes expresiones son -expresiones correctas? Cuáles no lo son? Justificar cada respuesta.
6.- Definir en LISP la función miembro que se comporte de la siguiente manera: (en todos sus niveles): Ejem. > (miembro 'llaves '(pero donde habre (puesto (Epi) las (llaves))) ) T > (miembro 3 (1 2 (3 (8 9)) 9)) T 7.- Un palíndromo (o capicúa) es algo (un texto) que se lee igual tanto al derecho como al revés. Escribir una versión recursiva en LISP de esta función sin utilizar la función reverse. Ejem. > (palindromo '(1 2 3 4 5 4 3 2 1)) T > (palindromop '(1 2 3)) NIL 8.- Definir función en LCI que devuelve una lista, que es la intersección de dos listas Ejem. Inter 1..5 5..9 [5] 9.- Definir función en LCI que halla el máximo elemento de una lista Ejem. Maximo 3:2:5:11:8:Nil 11 10.- Indicar, para cada variable, cuáles de sus ocurrencias son libres y cuales ligadas, en las siguientes expresiones. Indicar a que -abstracción está ligada cada ocurrencia no libre. 11.- Definir en LISP la función agrupa que dada una lista de elementos forme una lista con sublistas de tamaño n Ejem. (agrupa (a d e s f t g h o) 2) > ((a d) (e s) (f t) (g h) (o)) (agrupa (a s d e r f t g s) 3) > ((a s d) (e r f) (t g s)) 12.- Definir en LISP la función miembro que se comporte de la siguiente manera: (en todos sus niveles):
Ejem. > (miembro 'llaves '(pero donde habre (puesto (Epi) las (llaves))) ) T > (miembro 3 (1 2 (3 (8 9)) 9)) T 13.- Definir función en LCI que devuelva los últimos n elementos de una lista Ejem. Ultimos 3 1..15 [13, 14, 15] 14.- Definir función en LCI que determina si una lista es palíndroma Ejem. Palindroma 3:2:5:2:3:Nil \x.\y.x 15.- Si definimos la negación como p p := q.q de.e wz.w Demostrar que p p (p p true) = true 16.- Definir función en LCI que halle la diferencia simétrica de dos listas Ejem. Difs 1..5 4..8 [1, 2, 3, 6, 7, 8] 17.- Definir función en LCI que quita elementos duplicados de una lista Ejem. Dupli 3:2:5:2:3:Nil [3, 2, 5]