Algoritmos y Estructuras de Datos I

74 Pages·2008·0.5 MB·Spanish

Contenido
Especificaci´on
(cid:73) clase 1, p. 3
(cid:73) clase 2, p. 28
(cid:73) clase 3, p. 48
Algoritmos y Estructuras de Datos I
(cid:73) clase 4, p. 78
Programaci´on funcional
(cid:73) clase 1: p. 94
(cid:73) clase 2: p. 114
(cid:73) clase 3: p. 131
DepartamentodeComputaci´on,FCEyN,UBA
(cid:73) clase 4: p. 154
2◦ cuatrimestre de 2008 (cid:73) clase 5: p. 181
Programaci´on imperativa
(cid:73) clase 1: p. 205
(cid:73) clase 2: p. 225
(cid:73) clase 3: p. 247
(cid:73) clase 4: p. 260
(cid:73) clase 5: p. 272
1 2
Cursada
(cid:73) clases te´oricas
(cid:73) Paula Zabala y Santiago Figueira
(cid:73) clases pr´acticas
Especificaci´on
(cid:73) Carlos L´opez Pombo, Pablo Turjanski y Mart´ın Urtasun
Clase 1
(cid:73) sitio web de la materia: www.dc.uba.ar/people/materias/algo1
(cid:73) r´egimen de aprobaci´on
Introducci´on a la especificaci´on de problemas (cid:73) parciales
(cid:73) 3 parciales
(cid:73) 3 recuperatorios (al final de la cursada)
(cid:73) trabajos pr´acticos
(cid:73) 3 entregas
(cid:73) 3 recuperatorios (cada uno a continuaci´on)
(cid:73) grupos de 4 alumnos
(cid:73) examen final (si lo dan en diciembre 2008 o febrero/marzo
2009, cuenta la nota de la cursada)
3 4
Objetivos y contenidos Especificaci´on, algoritmo, programa
(cid:73) Objetivos:
(cid:73) especificar problemas
(cid:73) describirlos de forma no ambigua 1. especificaci´on = descripci´on del problema
(cid:73) escribir programas sencillos
(cid:73) ¿qu´e problema tenemos?
(cid:73) tratamiento de secuencias
(cid:73) en lenguaje formal
(cid:73) razonar acerca de estos programas
(cid:73) describe propiedades de la soluci´on
(cid:73) demostrar matem´aticamente que un programa es correcto
(cid:73) vision abstracta del proceso de computaci´on (cid:73) Dijkstra, Hoare (an˜os 70)
(cid:73) manejo simbo´lico y herramientas para demostrar
2. algoritmo = descripci´on de la soluci´on (escrito para humanos)
(cid:73) Contenidos:
(cid:73) especificaci´on (cid:73) ¿c´omo resolvemos el problema?
(cid:73) describir problemas en un lenguaje formal (preciso, claro,
abstracto) 3. programa = descripci´on de la soluci´on (escrito para la
(cid:73) programaci´on funcional (Haskell) computadora)
(cid:73) parecido al lenguaje matem´atico
(cid:73) tambi´en, ¿c´omo resolvemos el problema?
(cid:73) escribir de manera simple algoritmos y estructuras de datos
(cid:73) usando un lenguaje de programaci´on
(cid:73) programaci´on imperativa (C++)
(cid:73) paradigma m´as difundido
(cid:73) m´as eficiente
(cid:73) se necesita para seguir la carrera
5 6
Problemas y solucio´n Problema vs. solucio´n
Si voy a escribir un programa, es porque hay un problema a Parece una diferencia trivial
resolver (cid:73) en los ejemplos, es clara
(cid:73) a veces, la descripci´on es vaga o ambigua (cid:73) pero es f´acil confundirlos
(cid:73) no siempre es claro que haya soluci´on Ejemplo:
(cid:73) no siempre involucra uno o m´as programas de computaci´on (cid:73) confundir el problema con la soluci´on:
A: “tengo un problema: necesito un alambre”
Ejemplos de problemas: B: “no tengo”
(cid:73) cerr´e el auto con las llaves adentro (cid:73) en realidad, ese no era el problema:
(cid:73) seguramente tiene soluci´on, sin programas A: “tengo un problema: cerr´e el auto con las llaves adentro”
(cid:73) quiero calcular la edad de una persona B: “tom´a la copia de la llave que me pediste que te guardara
cuando compraste el auto”
(cid:73) tal vez podamos crear un programa
(cid:73) necesitamos que la empresa reduzca sus gastos en un 10%
(cid:73) confundir el problema con la soluci´on trae nuevos problemas
(cid:73) puede o no tener soluci´on, que puede o no requerir programas
(cid:73) es muy comu´n en computaci´on
nuevos o existentes
(cid:73) los programas de computadora casi nunca son la soluci´on
(cid:73) soy muy petiso completa
(cid:73) quiz´as no tenga soluci´on (cid:73) a veces forman parte de la soluci´on
7 (cid:73) ¡y a veces ni siquiera se necesitan! 8
Etapas en el desarrollo de programas 1. Especificacio´n
(cid:73) el planteo inicial del problema es vago y ambiguo
1. especificaci´on: definici´on precisa del problema
(cid:73) especificaci´on = descripci´on clara y precisa
↓ (cid:73) ´optimo: lenguaje formal, por ejemplo, el lenguaje de la l´ogica matem´atica
2. disen˜o: elegir una soluci´on y dividir el problema en partes
Por ejemplo, el problema de calcular de edad de una persona parece bien
↓ planteado, pero:
3. programaci´on: escribir algoritmos e implementarlos en algu´n (cid:73) ¿c´omo recibo los datos? manualmente, archivo en disco, sensor
lenguaje (cid:73) ¿cu´ales son los datos? fecha de nacimiento, taman˜o de la persona,
deterioro celular
↓
(cid:73) ¿c´omo devuelvo el resultado? pantalla, papel, voz alta, email
4. validaci´on: ver si el programa cumple con lo especificado (cid:73) ¿qu´e forma van a tener? d´ıas, an˜os enteros, fracci´on de an˜os
↓
Una buena especificaci´on responde algunas:
5. mantenimiento: corregir errores y adaptarlo a nuevos
(cid:73) Necesito una funci´on que, dadas dos fechas en formato dd/mm/aaaa, me
requerimientos devuelva la cantidad de d´ıas que hay entre ellas.
todav´ıa faltan los requerimientos no funcionales
(cid:73) forma de entrada de par´ametros y de salida de resultados, tipo de
E D P V M ··· computadora, tiempo con el que se cuenta para programarlo, etc.
(cid:73) no son parte de la especificaci´on funcional y quedan para otras materias
9 10
2. Disen˜o 3. Programaci´on - Algoritmos
Pensar en la soluci´on al problema. Escribir un algoritmo:
(cid:73) pasos precisos para llegar al resultado buscado de manera efectiva
Etapa en la que se responde
(cid:73) primero tienen que estar definidos los pasos primitivos
(cid:73) ¿varios programas o uno muy complejo?
(cid:73) ¿c´omo dividirlo en partes, qu´e porci´on del problema resuelve Ejemplo de algoritmo para la especificaci´on
cada una? Necesito una funci´on que, dadas dos fechas a y b en formato
(cid:73) ¿distintas partes en distintas m´aquinas? dd/mm/aaaa, me devuelva la cantidad de d´ıas que hay entre ellas.
(cid:73) estudio de las partes que lo componen
(cid:73) (mini) especificacio´n de cada parte 1. restar el an˜o de b al an˜o de a
(cid:73) un programador recibe una sola (o una por vez) 2. multiplicar el resultado por 365
3. sumarle la cantidad de d´ıas desde el 1◦ de enero del an˜o de b hasta el d´ıa b
(cid:73) ¿programas ya hechos con los que interactuar?
4. restarle la cantidad de d´ıas desde el 1◦ de enero del an˜o de a hasta el d´ıa a
(cid:73) lo van a ver en Algoritmos y Estructuras de Datos II y en 5. sumarle la cantidad de 29 de febrero que hubo en el per´ıodo
Ingenier´ıa del Software I 6. devolver ese resultado, acompan˜ado de la palabra “d´ıas”
¿Son todos primitivos? (3, 4, 5)
(cid:73) si no, hay que dar algoritmos para realizarlos
11 12
Pasos primitivos 3. Programaci´on - Programas
(cid:73) problema: sumar dos nu´meros naturales
(cid:73) algoritmos: (cid:73) traducir el algoritmo (escrito o idea) para que una
(cid:73) voy sumando uno al primero y restando uno al segundo, hasta computadora lo entienda
que llegue a cero (cid:73) lenguaje de programaci´on
(cid:73) sumo las unidades del primero a las del segundo, despu´es las
(cid:73) vamos a empezar usando uno: Haskell
decenas y as´ı (“llev´andome uno” cuando hace falta)
(cid:73) despu´es, C++
(cid:73) escribo el primero en una calculadora, aprieto +, escribo el
(cid:73) hay muchos otros
segundo, aprieto =
(cid:73) pueden ser m´as adecuados para ciertas tareas
(cid:73) los tres son v´alidos
(cid:73) depende del algoritmo, de la interfaz, tiempo de ejecuci´on, tipo
(cid:73) depende de qu´e operaciones primitivas tenga
de m´aquina, interoperabilidad, entrenamiento de los
(cid:73) sumar / restar uno programadores, licencias, etc.
(cid:73) sumar d´ıgitos (y concatenar resultados)
(cid:73) apretar una tecla de una calculadora
13 14
Representacio´n de los datos 4. Validaci´on
Asegurarse de que un programa cumple con la especificaci´on
(cid:73) testing
(cid:73) ya vimos que era importante en el ejemplo de calcular la edad
(cid:73) probar el programa con muchos datos y ver si hace lo que tiene
de una persona (d´ıas, meses, an˜os, fracciones de an˜o)
que hacer
(cid:73) otro ejemplo: (cid:73) en general, para estar seguro de que anda bien, uno tendr´ıa
(cid:73) contar la cantidad de alumnos de cada sexo que probarlo para infinitos datos de entrada
(cid:73) yo puedo darme cuenta a simple vista (a veces) (cid:73) si hay un error, con algo de suerte uno puede encontrarlo
(cid:73) la computadora probablemente no. ¿Que dato conviene tener? (cid:73) no es infalible (puede pasar el testing pero haber errores)
(cid:73) foto (cid:73) en Ingenier´ıa del Software I van a ver t´ecnicas para hacer
(cid:73) foto del documento testing
(cid:73) ADN (cid:73) verificaci´on formal
(cid:73) valor de la propiedad sexo para cada alumno
(cid:73) demostrar matem´aticamente que un programa cumple con una
(cid:73) estructuras de datos especificaci´on
(cid:73) necesarias para especificar (cid:73) es m´as dif´ıcil que hacer testing
(cid:73) puede ser que haya que cambiarlas al programar (cid:73) una demostraci´on cubre infinitos valores de entrada a la vez
(cid:73) las van a estudiar a fondo en Algoritmos y Estructuras de (abstracci´on)
Datos II (cid:73) es infalible (si est´a demostrado, el programa no tiene errores)
(cid:73) en esta materia van a estudiar c´omo demostrar que programas
simples son correctos para una especificaci´on
15 16
5. Mantenimiento Especificaci´on
(cid:73) objetivos:
(cid:73) tiempo despu´es, encontramos errores (cid:73) antes de programar: entender el problema
(cid:73) despu´es de programar: determinar si el programa es correcto
(cid:73) el programa no cumpl´ıa la especificaci´on
(cid:73) la especificaci´on no describ´ıa correctamente el problema (cid:73) testing
(cid:73) verificacio´n formal
(cid:73) o cambian los requerimientos
(cid:73) derivacio´n(construyoelprogramaapartirdelaespecificacio´n)
(cid:73) puede hacerlo el mismo equipo u otro
(cid:73) justifica las etapas anteriores (cid:73) estrategia:
(cid:73) si se hicieron bien la especificaci´on, disen˜o, programaci´on y (cid:73) evitar pensar (todav´ıa) una soluci´on para el problema
validaci´on, las modificaciones van a ser m´as sencillas y menos (cid:73) limitarse a describir cu´al es el problema a resolver
frecuentes (cid:73) qu´e propiedades tiene que cumplir una solucio´n para resolver
el problema
(cid:73) buscamos el qu´e y no el co´mo
17 18
Instancias de un problema Problemas funcionales
(cid:73) ejemplo de problema: arreglar una cafetera
(cid:73) para solucionarlo, necesitamos m´as datos
(cid:73) no podemos especificar formalmente cualquier problema
(cid:73) ¿qu´e clase de cafetera es?
(cid:73) ¿qu´e defecto tiene? (cid:73) el hambre en el mundo
(cid:73) ¿cu´anto presupuesto tenemos? (cid:73) la salud de Sandro
(cid:73) simplificaci´on (para esta materia)
(cid:73) se llaman par´ametros del problema
(cid:73) problemas que puedan solucionarse con una funci´on
(cid:73) cada combinaci´on de valores de los par´ametros es una
(cid:73) par´ametros de entrada
instancia del problema
(cid:73) un resultado para cada combinaci´on de valores de entrada
(cid:73) una instancia: “arreglar una cafetera de filtro cuya jarra pierde
agua, gastando a lo sumo $30”
(cid:73) los valores de los par´ametros se llaman argumentos
19 20
Tipos de datos Encabezado de un problema
Indica la forma que debe tener una soluci´on.
problema nombre(par´ametros) =nombreRes :tipoRes
Cada par´ametro tiene un tipo de datos
(cid:73) conjunto de valores para los que hay ciertas operaciones
definidas (cid:73) nombre: nombre que le damos al problema
(cid:73) ser´a resuelto por una funci´on con ese mismo nombre
Por ejemplo: (cid:73) nombreRes: nombre que le damos al resultado
(cid:73) par´ametros de tipo fecha (cid:73) tipoRes: tipo de datos del resultado
(cid:73) valores: ternas de nu´meros enteros (cid:73) par´ametros: lista que da el tipo y el nombre de cada uno
(cid:73) operaciones: comparaci´on, obtener el an˜o,...
(cid:73) par´ametros de tipo dinero Ejemplo
(cid:73) problema resta(minuendo,sustraendo : Int)= res : Int
(cid:73) valores: nu´meros reales con dos decimales
(cid:73) operaciones: suma, resta,... (cid:73) la funci´on se llama resta
(cid:73) da un resultado que vamos a llamar res
(cid:73) y es de tipo Int (los enteros)
(cid:73) depende de dos par´ametros: minuendo y sustraendo
(cid:73) tambi´en son de tipo Int
21 22
Contratos Partes de una especificacio´n
(cid:73) la funci´on que solucione el problema va a ser llamada o invocada por
un usuario
(cid:73) puede ser el programador de otra funci´on Tiene 3 partes
(cid:73) especificaci´on = contrato entre el programador de una funci´on que
1. encabezado (ya lo vimos)
resuelva el problema y el usuario de esa funci´on
2. precondici´on
(cid:73) condici´on sobre los argumentos
Por ejemplo:
(cid:73) el programador da por cierta
(cid:73) problema: calcular la ra´ız cuadrada de un real
(cid:73) lo que requiere la funci´on para hacer su tarea
(cid:73) soluci´on (funci´on)
(cid:73) por ejemplo: “el valor de entrada es un real no negativo”
(cid:73) va a tener un par´ametro real
3. poscondici´on
(cid:73) va a calcular un resultado real
(cid:73) para hacer el c´alculo, debe recibir un nu´mero no negativo (cid:73) condici´on sobre el resultado
(cid:73) debe ser cumplida por el programador, siempre y cuando el
(cid:73) compromiso para el usuario: no puede proveer nu´meros negativos
usuario haya cumplido la precondici´on
(cid:73) derecho para el programador de la funci´on: puede suponer que el
(cid:73) lo que la funci´on asegura que se va a cumplir despu´es de
argumento recibido no es negativo
llamarla (si se cumpl´ıa la precondici´on)
(cid:73) el resultado va a ser la ra´ız del nu´mero
(cid:73) por ejemplo: “la salida es la ra´ız del valor de entrada”
(cid:73) compromiso del programador: debe calcular la ra´ız, siempre y cuando
haya recibido un nu´mero no negativo
(cid:73) derecho del usuario: puede suponer que el resultado va a ser correcto
23 24
El contrato dice: Lenguaje naturales y lenguajes formales
El programador va a hacer un programa P tal que si el (cid:73) lenguajes naturales
usuario suministra datos que hacen verdadera la (cid:73) idiomas (castellano)
precondicio´n, entonces P va a terminar en una cantidad (cid:73) mucho poder expresivo (emociones, deseos, suposiciones y dem´as)
(cid:73) con un costo (conocimiento del contexto, experiencias compartidas
finita de pasos y va a devolver un valor que hace
ambigu¨edad e imprecisi´on)
verdadera la poscondici´on.
(cid:73) queremos evitarlo al especificar
(cid:73) si el usuario no cumple la precondici´on y P se cuelga o no (cid:73) lenguajes formales
cumple la poscondici´on... (cid:73) limitan lo que se puede expresar
(cid:73) ¿el usuario tiene derecho a quejarse? No. (cid:73) todas las suposiciones quedan expl´ıcitas
(cid:73) ¿se viola el contrato? No. El contrato prev´e este caso y dice (cid:73) relaci´on directa entre lo escrito (sintaxis) y su significado (sem´antica)
que P solo debe funcionar en caso de que el usuario cumpla (cid:73) pueden tratarse formalmente
con la precondici´on (cid:73) s´ımbolos manipulables directamente
(cid:73) si el usuario cumple la precondici´on y P se cuelga o no cumple (cid:73) seguridad de que las manipulaciones son v´alidas tambi´en para el significado
(cid:73) ejemplo: aritm´etica
la poscondici´on...
(cid:73) lenguaje formal para los nu´meros y sus operaciones
(cid:73) ¿el usuario tiene derecho a quejarse? S´ı.
(cid:73) resolvemos problemas simbo´licamente sin pensar en los significados
(cid:73) ¿se viola el contrato? S´ı. Es el u´nico caso en que se viola el num´ericos y llegamos a resultados correctos
contrato. El programador no hizo lo que se hab´ıa (cid:73) en Teor´ıa de Lenguajes y L´ogica y Computabilidad van a estudiarlos en
comprometido a hacer. profundidad
25 26
Especificaci´on formal
(cid:73) ya aprendimos a escribir encabezados
(cid:73) tenemos que dar tambi´en
(cid:73) la precondici´on (lo que la funci´on requiere) Especificaci´on
(cid:73) la poscondici´on (lo que asegura)
Clase 2
(cid:73) usamos un lenguaje formal para describir la precondici´on y la
poscondici´on
(cid:73) ejemplo de problema: calcular la ra´ız cuadrada de un nu´mero L´ogica proposicional - tipos b´asicos
(cid:73) lo llamamos rcuad
(cid:73) Float representa el conjunto R
problema rcuad(x :Float)=result :Float {
requiere x ≥0;
asegura result∗result ==x;
}
27 28
Lo´gica proposicional - sintaxis Ejemplos
(cid:73) s´ımbolos
true , false , ⊥ , ¬ , ∧ , ∨ , → , ↔ , ( , )
¿Cu´ales son f´ormulas?
(cid:73) variables proposicionales (infinitas) (cid:73) p∨q no
(cid:73) (p∨q) s´ı
p , q , r , ...
(cid:73) p∨q →r no
(cid:73) f´ormulas
(cid:73) (p∨q) →r no
1. true, false y ⊥ son f´ormulas
2. cualquier variable proposicional es una f´ormula (cid:73) ((p∨q)→ r) s´ı
3. si A es una f´ormula, ¬A es una f´ormula (cid:73) (p →q →r) no
4. si A ,A ,...,A son f´ormulas, (A ∧A ∧···∧A ) es una
1 2 n 1 2 n
f´ormula
5. si A ,A ,...,A son f´ormulas, (A ∨A ∨···∨A ) es una
1 2 n 1 2 n
f´ormula
6. si A y B son f´ormulas, (A→B) es una f´ormula
7. si A y B son f´ormulas, (A↔B) es una f´ormula
29 30
Sem´antica cl´asica Sem´antica cl´asica
Conociendo el valor de las variables proposicionales de una
(cid:73) 2 valores de verdad posibles f´ormula, conocemos el valor de verdad de la f´ormula
1. verdadero (1)
p q (p∧q) p q (p∨q)
2. falso (0)
p ¬p 1 1 1 1 1 1
(cid:73) interpretaci´on:
1 0 1 0 0 1 0 1
(cid:73) true siempre vale 1 0 1 0 1 0 0 1 1
(cid:73) false siempre vale 0 0 0 0 0 0 0
(cid:73) ¬ se interpreta como “no”, se llama negaci´on
(cid:73) ∧ se interpreta como “y”, se llama conjunci´on
p q (p →q) p q (p ↔ q)
(cid:73) ∨ se interpreta como “o”(no exclusivo), se llama disyunci´on
1 1 1 1 1 1
(cid:73) → se interpreta como “si... entonces”, se llama implicaci´on
(cid:73) ↔ se interpreta como “si y solo si”, se llama doble implicaci´on 1 0 0 1 0 0
o equivalencia 0 1 1 0 1 0
0 0 1 0 0 1
31 32
Ejemplo: tabla de verdad para ((p ∧ q) → r) Sem´antica trivaluada
(cid:73) 3 valores de verdad posibles
1. verdadero (1)
2. falso (0)
p q r (p∧q) ((p∧q) →r) 3. indefinido (−)
1 1 1 1 1 (cid:73) es la que vamos a usar en esta materia
1 1 0 1 0 (cid:73) ¿por qu´e?
1 0 1 0 1 (cid:73) queremos especificar problemas que puedan resolverse con un
1 0 0 0 1 algoritmo
0 1 1 0 1 (cid:73) puede ser que un algoritmo realice una operaci´on inv´alida
0 1 0 0 1 (cid:73) dividir por cero
(cid:73) ra´ız cuadrada de un nu´mero negativo
0 0 1 0 1
0 0 0 0 1 (cid:73) necesitamos contemplar esta posibilidad en la especificaci´on
(cid:73) interpretaci´on:
(cid:73) true siempre vale 1
(cid:73) false siempre vale 0
(cid:73) ⊥ siempre vale −
(cid:73) se extienden las definiciones de ¬,∧,∨,→,↔
33 34
Sem´antica trivaluada (secuencial) Sem´antica trivaluada (secuencial)
Se llama secuencial porque
(cid:73) los t´erminos se evalu´an de izquierda a derecha
Extendemos la sem´antica de →, ↔
(cid:73) la evaluaci´on termina cuando se puede deducir el valor de
verdad, aunque el resto est´e indefinido
p q (p →q) p q (p ↔ q)
Extendemos la sem´antica de ¬, ∧, ∨ 1 1 1 1 1 1
1 0 0 1 0 0
p q (p∧q) p q (p∨q)
0 1 1 0 1 0
1 1 1 1 1 1
0 0 1 0 0 1
1 0 0 1 0 1
1 − − 1 − −
p ¬p 0 1 0 0 1 1
0 − 1 0 − −
1 0 0 0 0 0 0 0
− 1 − − 1 −
0 1 1 − − 1 − 1
− 0 − − 0 −
− − 0 − 0 0 − −
− − − − − −
− 1 − − 1 −
− 0 − − 0 −
− − − − − −
35 36
Dos conectivos bastan Tautolog´ıas, contradicciones y contingencias
(cid:73) una f´ormula es una tautolog´ıa si siempre toma el valor 1 para
(cid:73) ¬ y ∨
valores definidos de sus variables proposicionales
(cid:73) (A∧B) es ¬(¬A∨¬B) Por ejemplo, ((p∧q) →p) es tautolog´ıa:
(cid:73) (A→B) es (¬A∨B)
p q (p∧q) ((p∧q) → p)
(cid:73) true es (A∨¬A)
1 1 1 1
(cid:73) false es ¬true
1 0 0 1
(cid:73) ¬ y ∧
0 1 0 1
(cid:73) (A∨B) es ¬(¬A∧¬B) 0 0 0 1
(cid:73) (A→B) es ¬(A∧¬B)
(cid:73) una f´ormula es una contradicci´on si siempre toma el valor 0
(cid:73) false es (A∧¬A)
para valores definidos de sus variables proposicionales
(cid:73) true es ¬false
Por ejemplo, (p∧¬p) es contradicci´on:
(cid:73) ¬ y →
p ¬p (p∧¬p)
(cid:73) (A∨B) es (¬A→B)
1 0 0
(cid:73) (A∧B) es ¬(A→¬B)
0 1 0
(cid:73) true es (A→A)
(cid:73) false es ¬true (cid:73) una f´ormula es una contingencia cuando no es ni tautolog´ıa ni
contradicci´on
37 38
Relacio´n de fuerza Lenguaje de especificacio´n
Decimos que A es m´as fuerte que B cuando (A→B) es tautolog´ıa.
Tambi´en decimos que A fuerza a B o que B es m´as d´ebil que A.
(cid:73) hasta ahora vimos l´ogica proposicional
Por ejemplo, (cid:73) es muy limitada
(cid:73) nuestro objetivo es especificar (describir problemas)
(cid:73) ¿(p∧q) es m´as fuerte que p? s´ı
(cid:73) vamos a usar un lenguaje m´as poderoso
(cid:73) ¿(p∨q) es m´as fuerte que p? no
(cid:73) permite hablar de elementos y sus propiedades
(cid:73) ¿p es m´as fuerte que (q → p)? s´ı (cid:73) es un lenguaje tipado
(cid:73) ¿p es m´as fuerte que q? no (cid:73) los elementos pertenecen a distintos dominios o conjuntos
(enteros, reales, etc.)
(cid:73) ¿p es m´as fuerte que p? s´ı
(cid:73) ¿hay una f´ormula m´as fuerte que todas? s´ı, por ej. false
(cid:73) ¿hay una f´ormula m´as d´ebil que todas? s´ı, por ej. true
39 40