Nota 2. Luis Sierra. Marzo del 2010

Transcripción

1 Nota 2 Luis Sierra Marzo del 2010 Cada mecanismo de definición de conjuntos que hemos comentado sugiere mecanismos para definir funciones y probar propiedades. Recordemos brevemente qué son las funciones y las propiedades, y cómo las definimos y probamos cuando nos encontramos ante conjuntos definidos por extensión y por comprensión. Una función es una correspondencia que se establece entre dos conjuntos, que cumple que (totalidad) a todo elemento del primer conjunto le corresponde un elemento del segundo conjunto, y (funcionalidad) dicho elemento es único. Llamamos dominio al primer conjunto, y recorrido al segundo. En ocasiones se les llama funciones totales a las funciones, y se habla de funciones parciales para referirse a las correspondencias que cumplen el requisito de funcionalidad, pero no necesariamente el de totalidad. Nuestras funciones serán siempre funciones totales. Usamos la notación habitual para declarar una función f cuyo dominio es A y su recorrido es B: f : A B Si nuestro dominio ha sido definido por extensión, la regla de correspondencia solamente se puede establecer a partir del objeto en cuestión. No es necesaria la existencia de ningún vínculo común entre los distintos elementos del dominio, y en consecuencia la función debe elegir un correspondiente sin más conocimiento que el que tenga del objeto en cuestión 1. Por ejemplo, si 1 Dicho conocimiento podría ser mucho, pero no está proporcionado por la definición del lenguaje. 1

2 el dominio fuera {AAAA, a, 123} y el codominio los naturales, una función puede definirse como f.aaaa : 75 f.a : f.123 : 321 Ahora bien, si nuestro dominio A hubiera sido definido por comprensión, la función podría definirse considerando la propiedad que lo define. Por ejemplo, si el dominio fuera {n N : n < 10 o n > 100} y el codominio los naturales, una función puede definirse como f.n : 2 n + 1 si n < 10 f.n : 2 n 1 si n > 100 Así como la definición de la función sigue la definición del dominio, también lo hacen las pruebas de propiedades. Por ejemplo, podemos probar que la imagen de la función f está formada por números impares. En el caso de la definición por extensión, debemos considerar cada caso como un caso especial. Vemos que la propiedad vale, porque para cada elemento del dominio inspeccionamos su correspondiente, y observamos que es impar. La situación mejora un poco si usamos la definición por comprensión. Nuestra prueba se convierte en un análisis de casos: en uno de ellos, observamos que 2 n 1 es un impar, y en el segundo que 2 n + 1 lo es. En esta sección daremos un formato para definir lenguajes inductivos, y mostraremos cómo estas definiciones generan esquemas para definir funciones y probar propiedades. 1. Conjuntos por extensión con definiciones inductivas Las definiciones inductivas se establecen mediante reglas básicas y reglas inductivas. Comenzamos con un ejemplo de lenguaje inductivo cuyas únicas reglas son básicas. Consideremos el siguiente lenguaje definido por extensión: Dígito : { 0, 1} Una definición inductiva para el mismo sería 2

3 El lenguaje Dígito queda definido con las siguientes reglas: RB1 0 Dígito RB2 1 Dígito Sin embargo, optaremos por la siguiente sintaxis 2. data Digito CERO UNO Si queremos definir una función con ese dominio deberemos indicar el valor en cada caso. Por ejemplo, las funciones que devuelven el valor entero correspondiente a un dígito, o su opuesto, pueden definirse como toint :: Digito -> Int toint CERO 0 toint UNO 1 opuesto :: Digito -> Digito opuesto CERO UNO opuesto UNO CERO También podemos definir la función que suma dos dígitos: sumar :: Digito -> Digito -> Digito sumar CERO b b sumar UNO b opuesto b Ahora podemos probar algunas propiedades sobre estos programas. Por ejemplo, podemos probar que ( d Dígito :: sumar.d.d 0) La prueba analiza todos las maneras de formar elementos de Dígito. Hay solamente dos posibilidades. d 0 Se desea probar sumar La prueba es la siguiente: sumar (Def.) 0 2 Esto permitirá una traducción más directa a Haskell. 3

4 d 1 Se desea probar sumar La prueba es la siguiente: sumar (Def.) opuesto. 1 (Def.) 0 Como la prueba analiza todos los casos posibles de formar elementos de Dígito, concluímos que hemos probado la propiedad para todos los elementos de Dígito. 2. Definiciones francamente inductivas En esta sección extendemos nuestro estudio a un lenguaje que cuenta con una regla inductiva. Llamamos numerales a las palabras de este lenguaje, ya que representan números. Una palabra del lenguaje (o tipo de datos) Numeral consiste de una secuencia no vacía de dígtos. Por lo tanto, hay dos formas de construir sus elementos: o tomando un dígito, o agregando un dígito a un numeral previamente construído. Una definición inductiva para el mismo sería El lenguaje Numeral queda definido con las siguientes reglas: RB Si d Dígito, entonces Ini d Numeral RI Si d Dígito y w Numeral, entonces Cons w d Numeral En nuestra sintaxis más lacónica, escribiremos data Numeral Ini Digito Cons Numeral Digito Si queremos definir una función con ese dominio deberemos indicar el valor en cada caso. Por ejemplo, estudiemos la función que devuelve el valor entero correspondiente a un numeral toint :: Numeral -> Int toint (Ini d) Digito.toInt d toint (Cons w d) let r Numeral.toInt w in 2 * r + Digito.toInt d 4

5 El primer renglón declara el tipo de la función: el dominio sera Numeral, y el recorrido los enteros. El segundo renglón indica la regla de cómputo correspondiente a una palabra del lenguaje formada con la primera regla de construcción del lenguaje. Lo llamamos el caso base de la recursión. El último renglón indica la regla de cómputo correspondiente a una palabra del lenguaje formada con la regla inductiva de construcción del lenguaje. El uso de la regla inductiva Cons Numeral Digito es el siguiente: dadas una palabra w del lenguaje Numeral y una palabra d del lenguaje Dígito, se construye una nueva palabra Cons w d del lenguaje Numeral. Al momento de definir una función recursiva f, la regla de cómputo correspondiente nos indica el programa que: dadas una palabra w del lenguaje Numeral y una palabra d del lenguaje Dígito, y asumiendo conocido f.w, el valor de aplicar la función a la palabra w, construye el valor correspondiente a w. Observe que cuando usamos el mismo nombre para dos funciones con distinto dominio, desambiguamos la situación prefijando el nombre de la función. La definición inductiva del tipo Numeral nos proporciona la siguiente estructura de programa, que tendremos que acomodar a nuestros fines: f :: Numeral ->... f (Ini d)... f (Cons w d) let r f w in... Por ejemplo, consideremos la programación de la función sucesor que calcula el sucesor de un numeral dado. Apenas conocido el dominio de la función ya tenemos un esqueleto inicial de nuestro programa. sucesor :: Numeral -> Numeral sucesor (Ini d)... sucesor (Cons w d) let r sucesor w in... El caso base de la recursión lo resolvemos fácilmente, ya que intuitivamente conocemos el resultado deseado: el sucesor del cero es el uno, y el del uno es el diez (dos en binario). 5

6 sucesor :: Numeral -> Numeral sucesor (Ini d) if d CERO then Ini UNO else Cons (Ini UNO) CERO sucesor (Cons w d) let r sucesor w in... El sucesor de un número binario de varios dígitos depende del dígito menos significativo. Si este es cero, el sucesor modifica este último dígito, y si es uno, debe considerar el acarreo resultante. Esta consideración termina la definición de la función. sucesor :: Numeral -> Numeral sucesor (Ini d) if d CERO then Ini UNO else Cons (Ini UNO) CERO sucesor (Cons w d) let r sucesor w in if d CERO then Cons w UNO else Cons r CERO 2.1. Probando propiedades La función sucesor que hemos definido en la sección anterior debe cumplir con una propiedad bien definida: dónde ( w Numeral :: P.w) P.w : toint.sucesor.w 1 + toint.w. Consideremos el numeral Ini 0. Analizando cada lado de la igualdad con las definiciones de sucesor, Numeral.toInt, y Dígito.toInt, observamos que toint.sucesor.(ini 0) toint.(ini 1) 1, 6 y 1 + toint.(ini 0) 1 + toint

7 La propiedad vale si el numeral fuera Ini 0 ya que De igual forma, analizando cada lado de la igualdad con las definiciones de sucesor, Numeral.toInt, y Dígito.toInt, vemos que toint.sucesor.(ini 1) toint.(cons (Ini 1) 0) 2 toint(ini 1) + toint. 0 2 toint( 1) , y 1 + toint.(ini 1) 1 + toint La propiedad vale si el numeral fuera Ini 1 ya que Hemos demostrado que cualquier numeral formado por la primera regla de construcción cumple con la propiedad P, es decir: ( d Dígito :: P.(Ini d)) Nos resta mostrar que los numerales formados con la otra regla también cumplen con la propiedad deseada. Es decir, quisiéramos probar ( d Dígito, w Numeral :: P.(Cons w d)) Analizando cada lado de la igualdad con las definiciones de sucesor, Numeral.toInt, y Dígito.toInt, vemos que toint.sucesor.(cons w 0) toint.(cons w 1) 2 toint.w + toint. 1 2 toint.w + 1, y 1 + toint.(cons w 0) toint.w + toint toint.w + 0. La propiedad vale si el numeral fuera Cons w 0 ya que 2 toint.w toint.w

8 Finalmente, nos queda por estudiar el caso en que el dígito menos significativo es 1. Tenemos que toint.sucesor.(cons w 1) toint.(cons (sucesor w) 0) 2 toint.(sucesor w) + toint. 0 2 toint.(sucesor w) + 0, y 1 + toint.(cons w 1) toint.w + toint toint.w + 1. Observemos que este caso se cumpliría si supiéramos que toint.(sucesor w) 1 + toint.w, que es precisamente la propiedad buscada para w. Es decir, hemos demostrado ( d Dígito, w Numeral : P.w : P.(Cons w d)) Las definiciones inductivas nos dan un esquema de prueba llamado Principio de Inducción Primitiva. En el caso del lenguaje Numeral, este principio establece que dada una propiedad P que habla de numerales, para justificar basta con probar ( w Numeral :: P.w) Caso base: ( d Dígito :: P.(Ini d)) Caso inductivo: ( d Dígito, w Numeral : P.w : P.(Cons w d)) En las páginas anteriores hemos demostrado el caso base y el caso inductivo de este principio, y por tanto hemos demostrado ( w Numeral :: toint.sucesor.w 1 + toint.w) El Principio de Inducción es un teorema Lo que hemos establecido como Principio de Inducción es un teorema que podemos demostrar fácilmente usando el principio de inducción sobre los naturales. Cada estructura de datos inductiva tiene asociado un principio. En esta sección probaremos el correspondiente a los numerales. Las hipótesis del teorema son las siguientes: 8

9 Propiedad: Sea P una propiedad que habla de los numerales, y que cumple Caso base: ( d Dígito :: P.(Ini d)) Caso inductivo: ( d Dígito, w Numeral : P.w : P.(Cons w d)) La tesis del teorema es la siguiente: Tesis: ( w Numeral :: P.w) Recordemos que el lenguaje de los numerales está definido 3 como las palabras formadas con secuencias de formación pautadas por las reglas. Probaremos que todas las palabras que surgen de secuencias de formación de cualquier largo cumplen con la propiedad P. Como estas son todas las palabras del lenguaje, habremos probado nuestra tesis. Hemos reformulado nuestra propiedad de la siguiente manera ( n N :: ( w Numeral : w n + 1 : P.w)), donde usamos w para denotar el largo de la secuencia 4 de formación de w. Usaremos el esquema fuerte de la inducción en los naturales para probar la siguiente propiedad Q sobre los naturales: Q.n : ( w Numeral : w n + 1 : P.w), Si bien para este lenguaje particular basta con el esquema débil, otros lenguajes más complejos requieren el uso del esquema fuerte. Para probar la propiedad basta con mostrar que se cumple la premisa del esquema fuerte de inducción. Es decir, ( n : ( m : m < n : Q.m) : Q.n). Consideremos dos casos: cuando n 0 y cuando n > 0. En el primer caso, deseamos probar ( w Numeral : w 1 : P.w). 3 Ver Nota En nuestras definiciones siempre existe un único árbol de formación, pero no necesariamente una única secuencia de formación. Ahora bien, en caso de que haya varias secuencias de formación, todas ellas tendrán el mismo largo. Una formulación más elegante es hablar de árboles de formación y hacer inducción sobre sus alturas; pero esto se aleja demasiado de la información estándar. 9

10 Observemos que hay solamente dos numerales con secuencia de formación de largo uno: Ini 0 e Ini 1. Ambos casos son hipótesis, las que hemos llamado el Caso base, lo que resuelve nuestro problema. Resta estudiar la situación cuando n > 0, nuestro segundo caso: ( w Numeral : w n + 1 : P.w) Si la secuencia de formación tiene largo n + 1 necesariamente debe terminar con el uso de un Cons. Si el numeral formado fuera Cons w d, tenemos que w fue formado en n pasos. Como la hipótesis del esquema fuerte garantiza que Q se cumple para todos los naturales menores que n, sabemos que se cumple Q.(n 1). Y el uso de la hipótesis que dimos en llamar Caso Inductivo termina la prueba. Mostramos ahora una versión más esquemática de las pruebas de Q.0 y Q.n que aparecen en la narración anterior. w 1 (Df. Numeral) ( d :: w Ini d) (Caso base) P.w. y w n + 1 (Df. Numeral) ( w, d : w n 1 : w Cons w d ) (Q.(n 1)) ( w, d : P.w : w Cons w d ) (Caso inductivo) P.w. 3. Esquema de recursión primitiva En esta sección exploraremos algunas definiciones atándonos al esquema de recursión primitiva (ERP). Esta será la forma de definir funciones a lo largo de estas notas. El ERP para el lenguaje de los numerales es un esqueleto de programa de la forma siguiente: f :: Numeral ->... f (Ini d)... f (Cons w d) let r f w in... 10

11 Ya hemos visto las funciones sucesor y toint. Programemos ahora la función par que indica si un numeral es par o no. Naturalmente, la función debe inspeccionar el dígito menos significativo del numeral. par :: Numeral -> Bool par (Ini d) d CERO par (Cons w d) let r par w in d CERO Observemos que no es necesario computar el paso recursivo. Acostumbramos escribir estas definiciones de forma más simple: par :: Numeral -> Bool par (Ini d) d CERO par (Cons w d) d CERO Investigar si un numeral es múltiplo de tres resulta más complicado. Una regla que resuelve el problema es la siguiente: Tomo el dígito menos significativo, y voy restando y sumando alternativamente los restantes dígitos módulo tres. Si la suma resultante es cero, entonces el numeral es múltiplo de tres. 5 Al intentar programar dicha función me encuentro con la necesidad de resolver el problema de la suma alternada. Si lo suponemos resuelto, al seguir el ERP encontramos no solamente que no computamos ningún paso recursivo, sino que ni siquiera programamos casos diferentes. mult3 :: Numeral -> Bool mult3 (Ini d) sumaalternada (Ini d) 0 mult3 (Cons w d) sumaalternada (Cons w d) 0 En este caso, la recursión ha quedado relegada a la función sumaalternada. Aplicamos el ERP para esta función: mult3 :: Numeral -> Bool mult3 w sumaalternada w 0 5 La regla usada en la numeración decimal realiza solamente sumas. 11

12 sumaalternada :: Numeral -> Int sumaalternada (Ini d) Digito.toInt d sumaalternada (Cons w d) let r sumaalternada w in... Observemos la siguiente dificultad: si la función que programamos comienza sumando, comienza sumando siempre, incluso al realizar el llamado recursivo. Precisamos que a veces la suma alternada comience sumando, y a veces restando. Codificamos esta información como un nuevo argumento que la suma alternada deberá considerar: mult3 :: Numeral -> Bool mult3 w sumaalternada w True 0 sumaalternada :: Numeral -> Bool -> Int sumaalternada (Ini d) \b -> if b then Digito.toInt d else if d CERO then 0 else 2 sumaalternada (Cons w d) let r sumaalternada w in \b -> if d CERO then r (not b) else case r (not b) of 0 -> if b then 1 else 2 1 -> if b then 2 else 0 2 -> if b then 0 else 1 12