Lógica proposicional - sintaxis

I Sı́mbolos:
true , false , ⊥ , ¬ , ∧ , ∨ , → , ↔ , ( , )
Algoritmos y Estructuras de Datos I
I Variables proposicionales (infinitas)
Primer cuatrimestre de 2017 p , q , r , ...

Departamento de Computación - FCEyN - UBA

I Fórmulas
Especificación - clase 2 1. true, false y ⊥ son fórmulas
2. Cualquier variable proposicional es una fórmula
Lógica proposicional - tipos básicos 3. Si A es una fórmula, ¬A es una fórmula
4. Si A1 , A2 , . . . , An son fórmulas, (A1 ∧ A2 ∧ · · · ∧ An ) es una
fórmula
5. Si A1 , A2 , . . . , An son fórmulas, (A1 ∨ A2 ∨ · · · ∨ An ) es una
fórmula
6. Si A y B son fórmulas, (A → B) es una fórmula
7. Si A y B son fórmulas, (A ↔ B) es una fórmula
1 2

Semántica clásica Semántica clásica

I Dos valores de verdad posibles: Conociendo el valor de las variables proposicionales de una fórmula,
podemos calcular el valor de verdad de la fórmula:
1. verdadero (o bien “true”, “T” o “V”)
2. falso (o bien “false” o “F”) p q (p ∧ q) p q (p ∨ q)
I El valor de verdad de una fórmula se obtiene a partir del valor de p ¬p T T T T T T
verdad de sus subfórmulas: T F T F F T F T
F T F T F F T T
I true se interpreta como verdadero.
F F F F F F
I false se interpreta como falso.
I ¬A se interpreta como “no”, se llama negación
I ∧ se interpreta como “y”, se llama conjunción p q (p → q) p q (p ↔ q)
I ∨ se interpreta como “o”(no exclusivo), se llama disyunción T T T T T T
I → se interpreta como “si... entonces”, se llama implicación T F F T F F
I ↔ se interpreta como “si y solo si”, se llama doble implicación F T T F T F
o equivalencia F F T F F T

3 4
Ejemplo: tabla de verdad para ((p ∧ q) → r ) Dos conectivos bastan

I ¬y∨
I (A ∧ B) es ¬(¬A ∨ ¬B)
I (A → B) es (¬A ∨ B)
p q r (p ∧ q) ((p ∧ q) → r ) I true es (A ∨ ¬A)
T T T T T I false es ¬true
T T F T F
T F T F T I ¬y∧
T F F F T I (A ∨ B) es ¬(¬A ∧ ¬B)
F T T F T I (A → B) es ¬(A ∧ ¬B)
F T F F T I false es (A ∧ ¬A)
F F T F T I true es ¬false
F F F F T
I ¬y→
I (A ∨ B) es (¬A → B)
I (A ∧ B) es ¬(A → ¬B)
I true es (A → A)
I false es ¬true
5 6

Tautologı́as, contradicciones y contingencias Relación de fuerza

I Una fórmula es una tautologı́a si siempre toma el valor T para
valores definidos de sus variables proposicionales. I Decimos que A es más fuerte que B cuando (A → B) es tautologı́a.
Por ejemplo, ((p ∧ q) → p) es tautologı́a:
I También decimos que A fuerza a B o que B es más débil que A.
p q (p ∧ q) ((p ∧ q) → p)
T T T T I Por ejemplo,
T F F T
F T F T 1. ¿(p ∧ q) es más fuerte que p? sı́
F F F T 2. ¿(p ∨ q) es más fuerte que p? no
3. ¿p es más fuerte que (q → p)? sı́
I Una fórmula es una contradicción si siempre toma el valor F para
Pero notemos que si q está indefinido y p es verdadero
valores definidos de sus variables proposicionales.
entonces (q → p) está indefinido.
Por ejemplo, (p ∧ ¬p) es contradicción: 4. ¿p es más fuerte que q? no
p ¬p (p ∧ ¬p) 5. ¿p es más fuerte que p? sı́
T F F 6. ¿hay una fórmula más fuerte que todas? false!
F T F 7. ¿hay una fórmula más débil que todas? true

I Una fórmula es una contingencia cuando no es ni tautologı́a ni

contradicción. 7 8
Expresión bien definida Semántica trivaluada (secuencial)
Se llama secuencial porque ...
I los términos se evalúan de izquierda a derecha,
I Toda expresión está bien definida en un estado si todas las
proposiciones valen T o F . I la evaluación termina cuando se puede deducir el valor de verdad,
aunque el resto esté indefinido.
I Sin embargo, existe la posibilidad de que haya expresiones que no
estén bien definidas.
Introducimos los operadores lógicos ∧L (y-luego, o conditional and, o
I Por ejemplo, la expresión x/y no está bien definida si y = 0. cand), ∨L (o-luego o conditional or, o cor).
I Por esta razón, necesitamos una lógica que nos permita decir que p q (p ∧L q) p q (p ∨L q)
está bien definida la siguiente expresión T T T T T T
I y = 0 ∨ x/y = 5 T F F T F T
F T F F T T
I Para esto, introducimos tres valores de verdad:
F F F F F F
1. verdadero (T) T − − T − T
2. falso (F) F − F F − −
3. indefinido (−) − T − − T −
− F − − F −
− − − − − −
9 10

Semántica trivaluada (secuencial) Tipos de datos

¿Cuál es la tabla de verdad de →L ? I Un tipo de datos es un conjunto de valores (el conjunto base del
tipo) provisto de una serie de operaciones que involucran a esos
p q (p →L q) valores.
T T T
T F F I Para hablar de un elemento de un tipo T en nuestro lenguaje,
F T T escribimos un término o expresión
F F T
T − −
I Variable de tipo T
F − T
I Constante de tipo T
I Función (operación) aplicada a otros términos (del tipo T o de
− T −
otro tipo)
− F −
− − − I Todos los tipos tienen un elemento distinguido: ⊥ o Indef

11 12
Tipos de datos de nuestro lenguaje de especificación Tipo Z (números enteros)

I Su conjunto base son los números enteros.

I Básicos
I Constantes: 0 ; 1 ; −1 ; 2 ; −2 ; ...
I Enteros (Z) I Operaciones aritméticas:
I Reales (R) I a + b (suma); a − b (resta); abs(a) (valor absoluto)
I Booleanos (Bool) I a ∗ b (multiplicación); a div b (división entera);
I Caracteres (Char) I a mod b (resto de dividir a a por b), ab o pot(a,b) (potencia)
I Enumerados
I a / b (división, da un valor de R)

I Uplas
I Comparaciones de términos de tipo Z (dan un valor de tipo Bool):
I a<b (menor)
I Secuencias
I a≤b o a <= b (menor o igual)
I a>b (mayor)
I a≥b o a >= b (mayor o igual)

13 14

Tipo R (números reales) Z⊆R

I Su conjunto base son los números reales.

I Z es un subconjunto de R
I Constantes: 0 ; 1 ; −7 ; 81 ; 7,4552 ; π...
I Conversión de entero a real:
I Operaciones aritméticas:
I Si x ∈ Z, entonces x ∈ R
I Suma, resta y producto (pero no div y mod)
I a/b (división) I Conversión de real a entero (truncamiento):
I logb (a) (logaritmo) I bac o floor(a)
I Funciones trigonométricas I Ejemplo floor (7,57) = 7
I Los mismos operadores de comparación que para Z: I Conversión de real a entero (redondeo):
I a<b (menor) I round(a)
I a≤b o a <= b (menor o igual) I Ejemplo round(7,57) = 8
I a>b (mayor)
I a≥b o a >= b (mayor o igual)

15 16
Tipo Bool (valor de verdad) Tipo Bool (valores de verdad)

I ¬A se puede escribir no(A)

I Su conjunto base es B = {true, false}.
I Conectivos lógicos: ¬, ∧, ∨, →, ↔ con la semántica bi-valuada
I (A ∧ B) se puede escribir (A && B)
estándar. I (A ∨ B) se puede escribir (A || B)
I Comparación: A = B I (A → B) se puede escribir (A --> B)
I Si A y B son del mismo tipo, entonces A = B es una expresión I (A ↔ B) se puede escribir (A <--> B)
de tipo Bool que evalúa a true si A y B no están indefinidos y I A 6= B se puese escribir A 6= B. También se puede escribir
tienen el mismo valor. ¬(A = B)

17 18

Ejercicio Tipo Char (caracteres)

¿Cuáles de las siguientes son una especificación adecuada para el problema de decidir
si un número entero es positivo?
proc esPositivo (in x : Z, out r : Bool) { I Sus elementos son las letras, dı́gitos y sı́mbolos.

Pre{True}
I Constantes: ‘a‘, ‘b‘, ‘c‘, . . . , ‘z‘, . . . , ‘A‘, ‘B‘, ‘C ‘, . . . , ‘Z ‘, . . . ,
‘0‘, ‘1‘, ‘2‘, . . . , ‘9‘ (en el orden dado por el estándar ASCII).
1. Post{x > 0 ∧ r = true} I Función ord, que numera los caracteres, con las siguientes
2. Post{(x > 0 ∧ r = true) ∧ (x <= 0 ∧ r = false)} propiedades:
3. Post{(x > 0 ∧ r = true) ∨ (x <= 0 ∧ r = false)} I ord(‘a‘) + 1 = ord(‘b‘)
I ord(‘A‘) + 1 = ord(‘B‘)
4. Post{x ≤ 0 =⇒ r = false}
I ord(‘1‘) + 1 = ord(‘2‘)
5. Post{x > 0 =⇒ r = true}
I Función char, de modo tal que char(ord(c)) = c.
6. Post{(x > 0 =⇒ r = true) ∨ (x <= 0 =⇒ r = false)}
7. Post{x > 0 ⇐⇒ r = true}
I Las comparaciones entre caracteres son comparaciones entre sus
órdenes, de modo tal que a < b es equivalente a ord(a) < ord(b).
8. Post{x <= 0 ⇐⇒ r = false}

19 20
Tipos enumerados Ejemplo de tipo enumerado

I Cantidad finita de elementos.

Cada uno, denotado por una constante. Definimos el tipo Dı́a ası́:
enum Dı́a {
enum Nombre { constantes } Lunes, Martes, Miércoles, Jueves, Viernes, Sábado, Domingo
}
I Nombre (del tipo): tiene que ser nuevo.
I Valen:
I constantes: nombres nuevos separados por comas.
I ord(Lunes) = 0
I Convención: todos con mayúsculas. I Dı́a(2) = Miércoles
I ord(a) da la posición del elemento en la definición (empezando de I Jueves < Viernes
0).
I Inversa: El nombre del tipo funciona como inversa de ord.

21 22

Tipo upla (o tupla) Términos

I Simples (variables y constantes del tipo).

I Uplas, de dos o más elementos, cada uno de cualquier tipo.
I Complejos (combinaciones de funciones aplicadas a funciones,
I T0 × T1 × · · · × Tk : Tipo de las k-uplas de elementos de tipos T0 , constantes y variables).
T1 , ... Tk , respectivamente, donde k es fijo.
I Ejemplos:
Ejemplos de términos de tipo Z
I Z × Z son los pares ordenados de enteros. I 0+1
I Z × Char × Bool son las triplas ordenadas con un entero, luego
un carácter y luego un valor booleano. I ((3 + 4) ∗ 7)2 − 1
I nésimo: ha0 , . . . , ak im es el valor am en caso de que 0 ≤ m ≤ k. I 2 ∗ if (1 + 1 = 2) then 1 else 0 fi
Sino está indefinido. I 1 + ord(‘A‘)
I Ejemplos: I con x variable de tipo Z; y de tipo R; z de tipo Bool
I h7, 5i0 = 7 I 2∗x +1
I h‘a’, Domingo, 78i2 = 78 I (if (y 2 > π) then 1 else 0 fi ) + x
I (x mod 3) ∗ if (z) then 1 else 0 fi

23 24
Semántica de los términos Semántica de los términos
Con x e y variables de tipo Z, decidir el valor de verdad de los siguientes
I Vimos que los términos representan elementos de los tipos términos cuando x = 0 e y = 5:
I Los términos tienen valor indefinido cuando no se puede hacer I y 6= 5
alguna operación
I 1 div 0 I x/(y − 5) ≥ 0
I (−1)1/2
I y = 5 ∨L x/(y − 5) ≥ 0
I Las operaciones son estrictas
I Si uno de sus argumentos es indefinido, el resultado también I x/(y − 5) ≥ 0 ∨L y = 5
está indefinido
I Ejemplos: I y 6= 5 ∧L x/(y − 5) ≥ 0
I 0 ∗ (−1)1/2 es indefinido (∗ es estricto)
I 01/0 es indefinido (pot es estricto) I x/(y − 5) ≥ 0 ∧L y 6= 5
I ((1 + 1 = 2) ∨L (0 > 1/0)) es verdadero (∨L no es estricto)
I Las comparaciones con ⊥ son indefinidas
I (y 6= 5 ∧L x/(y − 5) ≥ 0) ∨L x = 0
I En particular, si x está indefinido, x = x es indefinido (no es
verdadero)
I y + abs(x/(y − 5)) ≥ 0
25 26

Funciones y predicados auxiliares Ejemplos de funciones auxiliares

I Asignan un nombre a una expresión.

I Facilitan la lectura y la escritura de especificaciones.
I Modularizan la especificación.
I fun e() : R = 2,7182;
I fun inverso(x : R) : R = 1/x;
fun f (argumentos) : tipo = expresion;
I pred par (n : Z) { (n mod 2) = 0 }
pred p(argumentos){formula}
pred impar (n : Z) { ¬ (par(n)) }
I f es el nombre de la función, que puede usarse en el resto de la
especificación en lugar de la expresión e. I pred esFinde(d : Dı́a){d = Sábado ∨ d = Domingo}
I Los argumentos son opcionales y se reemplazan en e cada vez Otra forma:
que se usa f . pred esFinde2(d : Dı́a){d > Viernes}
I tipo es el tipo del resultado de la función (el tipo de e).
I Ejemplo:
fun suc(x : Z) : Z = x + 1;

27 28
Expresiones condicionales Definir funciones auxiliares versus especificar problemas
Función que elige entre dos elementos del mismo tipo, según una Definimos funciones auxiliares
condición booleana (guarda)
I Expresiones del lenguaje, que se usan dentro de las especificaciones
I si la guarda es verdadera, elige el primero
como reemplazos sintácticos. Son de cualquier tipo.
I si no, elige el segundo
I Dado que es un reemplazo sintáctico, no se permiten definiciones
recursivas!
Por ejemplo
I expresión que devuelve el máximo entre dos elementos:
Especificamos problemas
fun máx(a, b : Z) : Z = IfThenElseFihZi(a > b, a, b);
I Condiciones (el contrato) que deberı́a cumplir un algoritmo para ser
cuando los argumentos se deducen del contexto, se puede escribir
solución del problema.
directamente
I En una especificación dando la precondición y la postcondición con
fun máx(a, b : Z) : Z = IfThenElseFi(a > b, a, b); o bien
predicados de primer orden.
fun máx(a, b : Z) : Z = if a > b then a else b fi;
I No podemos usar otros problemas en la especificación (dado que no
I expresión que dado x devuelve 1/x si x 6= 0 y 0 sino
pertenecen a la lógica de primer orden). Sı́ podemos usar predicados
fun unoSobre(x : R) : R = if x 6= 0 then 1/x else 0 fi; y funciones auxiliares ya definidos.
| {z }
no se indefine cuando x = 0
29 30

Especificar problemas Cuantificadores

El lenguaje de especificación provee formas de predicar sobre los

elementos de un tipo de datos
I Ejemplo: Especificar el problema de retornar el i-ésimo dı́gito de la I (∀x : T ) P(x): Término de tipo Bool. Afirma que todos los
representación decimal del número π. elementos de tipo T cumplen la propiedad P.
I Se lee “Para todo x de tipo T se cumple P(x)”
I proc piesimo(in i : Z, out result : Z) {
Pre {i > 0} I (∃x : T ) P(x): Término de tipo Bool. Afirma que al menos un
Post {result = bπ ∗ 10i c mod 10} elemento de tipo T cumple la propiedad P.
} I Se lee “Existe al menos un x de tipo T que cumple P(x)”

En la expresión (∀x : T ) P(x), la variable x está ligada al cuantificador.

Una variable es libre cuando no está ligada a ningún cuantificador.

31 32
Ejemplo Especificar problemas

I La conjetura de Goldbach dice que todo entero par mayor que 2

I Ejemplo: Crear un predicado esPrimo que sea Verdadero si y sólo puede ser expresado como la suma de dos números primos.
si el número n es un número primo.
I Ejemplo: Especificar un procedimiento que indique si esta conjetura
I pred esPrimo(n : Z) { es verdadera.
n > 1 ∧ (∀n0 : Z)(1 < n0 < n → n mod n0 6= 0)
} I proc goldbach(out result : Bool) {
Pre {True}
I Ejemplo: Especificar el problema de, dado un número mayor a 1, Post {result = (∀n : Z)(n > 2 ∧ n mod 2 = 0 →
indicar si el número es un número primo. (∃p : Z)(∃q : Z)(esPrimo(p) ∧ esPrimo(q) ∧ n = p + q))}
}
I proc primo(in n : Z, out result : Bool) {
Pre {n > 1} I Observar que estamos especificando el problema. Es posible que en
Post {result = esPrimo(n)} este punto no sepamos cómo vamos a resolver este problema (si es
} que se puede resolver!), y es bueno no pensar en eso al momento de
especificar.

33 34

Especificar problemas Repaso: Pasaje de parámetros

in, out, inout

I Ejemplo: Especificar un procedimiento que calcule el máximo

común divisor (mcd) entre dos números positivos.
I Parámetros de entrada (in): Parámetros con valores que se copian
I proc mcd(in n : Z, in m : Z, out result : Z) {
hacia el procedimiento.
Pre {n ≥ 1 ∧ m ≥ 1}
Post {n mod result = 0 ∧ m mod result = 0 ∧ I Parámetros de salida (out): Parámetros para que el procedimiento
¬(∃p : Z)(p > result ∧ n mod p = 0 ∧ m mod p = 0)} informe resultados al código llamador.
}
I Parámetros de entrada-salida (inout): Parámetros de entrada y
I Observar que no damos una fórmula que especifica el valor de salida.
retorno, sino que solamente damos las propiedades que debe
cumplir!

35 36
Especificar problemas Especificar problemas

I Ejemplo: Especificar un procedimiento que incremente en una

unidad una variable de tipo Z que representa un contador. I Ejemplo: Especificar un procedimiento que decremente en una
unidad una variable de tipo Z que representa un contador. Para
I proc inc(inout n : Z) { poder aplicar esta operación el contador tiene que ser mayor que 0.
Pre {n = n0 }
Post {n = n0 + 1} I proc dec(inout n : Z) {
} Pre {n = n0 ∧ n ≥ 1}
Post {n = n0 − 1}
I La variable n0 es una metavariable, que representa el valor inicial de }
la variable n, y que usamos en la postcondición para relacionar el
valor de salida de n con su valor inicial.

37 38

Especificar problemas Especificar problemas

I Ejemplo: Dados cuatro enteros a, b, c, d tales que

I a y b representan un número fraccionario ba y son coprimos
entre sı́, y
I c y d representan el número fraccionario dc y son coprimos I Continuación: Modificar la solución anterior para que el resultado
entre sı́, sean dos números coprimos entre sı́.
a c
escribir la especificación de un procedimiento que compute b + d y
coloque el resultado en dos números enteros. I proc suma(in a, b, c, d : Z, out e, f : Z) {
Pre {coprimos(a, b) ∧ coprimos(c, d)}
I proc suma(in a, b, c, d : Z, out e, f : Z) { Post { fe = ba + dc ∧ coprimos(e, f )}
Pre {coprimos(a, b) ∧ coprimos(c, d)} }
Post { fe = ba + dc }
}
I pred coprimos(n, m : Z) {
¬(∃i : Z)(i ≥ 2 ∧ n mod i = 0 ∧ m mod i = 0)
}

39 40
Especificando un semáforo Especificando un semáforo

I Continuación: Especificar un procedimiento que avance el estado

de las luces de un semáforo.

I Ejemplo: Representamos con tres valores de tipo Bool el estado de

la luz verde, amarilla y roja de un semáforo.

I Escribir el procedimiento que inicializa el semáforo con la luz roja y

el resto de las luces apagadas.
I proc avanzar (inout v , a, r : Bool) {
I proc iniciar (out v , a, r : Bool) {  
Pre {True} Pre { (r ∧ ¬v ) ∨ (v ∧ ¬r ∧ ¬a) ∨ (a ∧ ¬r ∧ ¬v ) ∧
Post {r ∧ ¬a ∧ ¬v } v = v0 ∧ r = r0 ∧ a = a0 }
} Post {((r0 ∧ ¬a0 ) → (r ∧ a ∧ ¬v )) ∧
((r0 ∧ a0 ) → (¬r ∧ ¬a ∧ v ) ∧
((v0 ) → (¬r ∧ a ∧ ¬v )) ∧
((¬r0 ∧ a0 ) → (r ∧ ¬a ∧ ¬v ))}
}

41 42