Otter proposicional

Una introducción a Otter
Otter: Demostrador mecánico de teoremas que usa resolución como
regla básica de deducción.
Por ahora vamos a estudiar Otter proposicional.
En Otter los conectivos lógicos son denotados como:
-p
:
¬p
p | q
:
p∨q
p & q
:
p∧q
p -> q
:
p→q
p <-> q
:
p↔q
Ejemplo: La fórmula (p ∧ q) → r es denotada como (p & q) -> r.
1
Otter: Archivo de entrada
Otter utiliza las mismas reglas de precedencia que nosotros usamos.
Ejemplo: La claúsula p ∨ q ∨ ¬r es denotada como p | q | -r.
En un archivo de entrada para Otter hay dos listas de fórmulas:
usable and sos.
- Otter trata de demostrar que la unión de estas dos listas es
inconsistente.
Si queremos demostrar que Σ |= ϕ, normalmente ponemos Σ en la
lista usable y ¬ϕ en la lista sos.
- Esta no es una regla general: También podemos poner ¬ϕ en
usable y Σ en sos.
2
Otter: Archivo de entrada
Ejemplo: Queremos demostrar que {p, p → q} |= q.
Entonces ponemos lo siguiente en usable y sos:
formula_list(usable).
p.
p -> q.
end_of_list.
formula_list(sos).
-q.
end_of_list.
3
Archivo de entrada: formula list versus list
formula_list: Indica que una lista puede contener fórmulas
arbitrarias y no solamente claúsulas.
- Otter transforma las fórmulas en claúsulas.
Si una lista contiene sólo claúsulas, entonces podemos usar list en
lugar de formula_list:
list(usable).
p.
-p | q.
end_of_list.
list(sos).
-q.
end_of_list.
4
La estrategia de Otter
Básicamente:
si sos = ∅ entonces retorne “no pude demostrarlo”
en caso contrario
elija una claúsula C1 ∈ sos
sos := sos − {C1 }
para cada claúsula C2 ∈ usable
si C1 = C3 ∨ l ∨ C4 y C2 = C5 ∨ l̄ ∨ C6 entonces
si C3 ∨ C4 ∨ C5 ∨ C6 = entonces retorne “lo pude demostrar”
en caso contrario sos := sos ∪ {C3 ∨ C4 ∨ C5 ∨ C6 }
Vamos a ver cada paso en detalle.
5
La estrategia de Otter: Un primer ejemplo
Archivo de entrada:
set(binary_res).
clear(factor).
clear(unit_deletion).
formula_list(usable).
p.
p -> q.
end_of_list.
formula_list(sos).
-q.
end_of_list.
6
La estrategia de Otter: Un primer ejemplo
set(binary res): Indica que vamos a usar resolución binaria.
clear(factor), clear(unit deletion): Indican que no queremos
usar ni factor ni unit deletion.
- Estas reglas son activadas cuando se activa la regla de
resolución binaria.
- Más tarde vamos a ver como se usan.
7
La estrategia de Otter: Un primer ejemplo
Invocación: otter < entrada > salida
Archivo de salida (casi completo):
set(binary_res).
dependent: set(factor).
dependent: set(unit_deletion).
clear(factor).
clear(unit_deletion).
-------> usable clausifies to:
list(usable).
1 [] p.
2 [] -p|q.
end_of_list.
8
La estrategia de Otter: Un primer ejemplo
-------> sos clausifies to:
list(sos).
3 [] -q.
end_of_list.
======= end of input processing =======
=========== start of search ===========
given clause #1: (wt=1) 3 [] -q.
** KEPT (pick-wt=1): 4 [binary,3.1,2.2] -p.
----> UNIT CONFLICT at
Length of proof is 1.
0.00 sec ----> 5 [binary,4.1,1.1] $F.
Level of proof is 1.
9
La estrategia de Otter: Un primer ejemplo
---------------- PROOF ---------------1
2
3
4
5
[] p.
[] -p|q.
[] -q.
[binary,3.1,2.2] -p.
[binary,4.1,1.1] $F.
------------ end of proof -------------
UNIT CONFLICT: Indica que la claúsula vacı́a puede ser obtenida por
resolución desde el literal generado y otro literal en la lista usable.
10
EL mecanismo de pesos
¿Cómo elige Otter una claúsula desde la lista sos?
A cada claúsula Otter le asigna un peso usando las siguientes reglas:
- La lista weight_list(pick_given) es usada para especificar
el peso de cada variable proposicional:
weight_list(pick_given).
weight(q,2).
end_of_list.
Si una variable no es mencionada su peso es 1.
11
EL mecanismo de pesos
- A cada literal negativo ¬p se le asigna un peso usando la regla:
peso(¬p) = peso(p) + neg weight,
donde neg_weight es una constante cuyo valor es asignado
usando la instrucción assign(neg weight, 5).
Si el valor de neg_weight no es asignado se asume que es 0.
- El peso de una claúsula es definido como la suma de los pesos
de sus literales.
12
EL mecanismo de pesos
Otter siempre elige primero las claúsulas de menor peso, tanto
desde la lista sos como desde la lista usable.
Ejemplo:
set(binary_res).
clear(factor).
clear(unit_deletion).
assign(neg_weight, -1).
formula_list(usable).
p.
p -> q.
end_of_list.
13
EL mecanismo de pesos
formula_list(sos).
r.
-q.
end_of_list.
Parte del archivo de salida:
=========== start of search ===========
given clause #1: (wt=0) 4 [] -q.
** KEPT (pick-wt=0): 5 [binary,4.1,2.2] -p.
----> UNIT CONFLICT at
Length of proof is 1.
0.00 sec ----> 6 [binary,5.1,1.1] $F.
Level of proof is 1.
14
EL mecanismo de pesos
La estrategia de Otter en más detalle:
si sos = ∅ entonces retorne “no pude demostrarlo”
en caso contrario
elija la claúsula C1 ∈ sos de menor peso
sos := sos − {C1 }
ordene usable de menor a mayor peso
para i := 1 hasta el número de claúsulas en usable
elija la i-ésima claúsula C2 de la lista usable
si C1 = C3 ∨ l ∨ C4 y C2 = C5 ∨ l̄ ∨ C6 entonces
si C3 ∨ C4 ∨ C5 ∨ C6 = entonces retorne “lo pude demostrar”
en caso contrario sos := sos ∪ {C3 ∨ C4 ∨ C5 ∨ C6 }
15
La estrategia de Otter: Otro ejemplo
Veamos una demostración un poco más complicada:
set(binary_res).
clear(factor).
clear(unit_deletion).
formula_list(usable).
p.
p -> q.
q -> r.
end_of_list.
formula_list(sos).
-r.
end_of_list.
16
La estrategia de Otter: Otro ejemplo
Parte de la salida:
-------> usable clausifies to:
list(usable).
1 [] p.
2 [] -p|q.
3 [] -q|r.
end_of_list.
-------> sos clausifies to:
list(sos).
4 [] -r.
end_of_list.
======= end of input processing =======
17
La estrategia de Otter: Otro ejemplo
=========== start of search ===========
given clause #1: (wt=1) 4 [] -r.
** KEPT (pick-wt=1): 5 [binary,4.1,3.2] -q.
5 back subsumes 3.
given clause #2: (wt=1) 5 [binary,4.1,3.2] -q.
** KEPT (pick-wt=1): 6 [binary,5.1,2.2] -p.
----> UNIT CONFLICT at
Length of proof is 2.
0.00 sec ----> 7 [binary,6.1,1.1] $F.
Level of proof is 2.
18
La estrategia de Otter: Otro ejemplo
---------------- PROOF ---------------1
2
3
4
5
6
7
[] p.
[] -p|q.
[] -q|r.
[] -r.
[binary,4.1,3.2] -q.
[binary,5.1,2.2] -p.
[binary,6.1,1.1] $F.
------------ end of proof -------------
19
La estrategia de Otter: Otro ejemplo
Otter elimina claúsulas usando la regla:
Si ϕ → ψ es una tautologı́a: Σ ∪ {ϕ, ψ} |= θ si y sólo si Σ ∪ {ϕ} |= θ.
Si una fórmula es implicada por otra, entonces la podemos eliminar
sin perder completidad.
Notación: Si ϕ → ψ es una tautologı́a, entonces decimos que ϕ
subsume a ψ.
20
La estrategia de Otter: Otro ejemplo
Esta regla es usada por Otter para eliminar la claúsula 3 de la lista
usable: ¬q ∨ r
Una vez que ¬q ha sido obtenida usando resolución (claúsula 5),
como ¬q → (¬q ∨ r) es una tautologı́a, ¬q ∨ r es eliminada.
5 back subsumes 3: Indica que la claúsula 5 subsume a la claúsula
3. La palabra back indica que una claúsula de la lista sos es usada
para eliminar una claúsula de la lista usable.
21
La estrategia de Otter: Otro ejemplo
Otter también puede eliminar claúsulas de la lista sos usando esta
regla:
set(binary_res).
clear(factor).
clear(unit_deletion).
list(usable).
-p | q.
end_of_list.
list(sos).
p.
q | r.
end_of_list.
22
La estrategia de Otter: Otro ejemplo
Parte de la salida:
=========== start of search ===========
given clause #1: (wt=1) 2 [] p.
** KEPT (pick-wt=1): 4 [binary,2.1,1.1] q.
4 back subsumes 3.
4 back subsumes 1.
given clause #2: (wt=1) 4 [binary,2.1,1.1] q.
Search stopped because sos empty.
============ end of search ============
23
La estrategia de Otter: forward subsumption
Otter también utiliza esta regla para no agregar una claúsula al sos
si es que esta es implicada por una claúsula en el usable o sos.
Esto es llamado forward subsumption:
set(binary_res).
clear(factor).
clear(unit_deletion).
list(usable).
q.
-p | q | r.
end_of_list.
list(sos).
p.
end_of_list.
24
La estrategia de Otter: forward subsumption
Parte de la salida:
=========== start of search ===========
given clause #1: (wt=1) 3 [] p.
Search stopped because sos empty.
============ end of search ============
25
La estrategia de Otter: forward subsumption
¿Por qué en el siguiente ejemplo no obtenemos la claúsula vacı́a?
set(binary_res).
clear(factor).
clear(unit_deletion).
list(usable).
q.
-q.
-r.
-p | q | r.
end_of_list.
list(sos).
p.
end_of_list.
26
La estrategia de Otter: forward subsumption
Parte de la salida:
=========== start of search ===========
given clause #1: (wt=1) 5 [] p.
Search stopped because sos empty.
============ end of search ============
27
La estrategia de Otter: forward subsumption
Si eliminamos “forward subsumption” entonces obtenemos la
claúsula vacı́a:
set(binary_res).
clear(factor).
clear(unit_deletion).
clear(for_sub).
list(usable).
q.
-q.
-r.
-p | q | r.
end_of_list.
28
La estrategia de Otter: forward subsumption
list(sos).
p.
end_of_list.
Parte de la salida:
=========== start of search ===========
given clause #1: (wt=1) 5 [] p.
** KEPT (pick-wt=2): 6 [binary,5.1,4.1] q|r.
6 back subsumes 4.
given clause #2: (wt=2) 6 [binary,5.1,4.1] q|r.
** KEPT (pick-wt=1): 7 [binary,6.1,2.1] r.
----> UNIT CONFLICT at
0.00 sec ----> 8 [binary,7.1,3.1] $F.
29
La estrategia de Otter: forward subsumption
La estrategia de Otter en aún más detalle
si sos = ∅ entonces retorne “no pude demostrarlo”
en caso contrario
elija la claúsula C1 ∈ sos de menor peso
sos := sos − {C1 }
ordene usable de menor a mayor peso
para i := 1 hasta el número de claúsulas en usable
elija la i-ésima claúsula C2 de la lista usable
si C1 = C3 ∨ l ∨ C4 y C2 = C5 ∨ ¯
l ∨ C6 entonces
si C3 ∨ C4 ∨ C5 ∨ C6 = entonces retorne “lo pude demostrar”
si no existe C7 ∈ usable ∪ sos que subsume a C3 ∨ C4 ∨ C5 ∨ C6 entonces
elimine todo C8 ∈ usable ∪ sos subsumido por C3 ∨ C4 ∨ C5 ∨ C6
sos := sos ∪ {C3 ∨ C4 ∨ C5 ∨ C6 }
30
La estrategia de Otter: Eliminación de tautologı́as
Otter también elimina claúsulas usando la regla:
Si α es una tautologı́a: Σ ∪ {α} |= β si y sólo si Σ |= β.
Podemos eliminar una tautologı́a generada sin perder completidad:
set(binary_res).
clear(factor).
clear(unit_deletion).
list(usable).
p | q.
end_of_list.
31
La estrategia de Otter: Eliminación de tautologı́as
list(sos).
-p | -q.
end_of_list.
Parte de la salida:
=========== start of search ===========
given clause #1: (wt=2) 2 [] -p| -q.
Search stopped because sos empty.
============ end of search ============
32
La estrategia de Otter
si sos = ∅ entonces retorne “no pude demostrarlo”
en caso contrario
elija la claúsula C1 ∈ sos de menor peso
sos := sos − {C1 }
ordene usable de menor a mayor peso
para i := 1 hasta el número de claúsulas en usable
elija la i-ésima claúsula C2 de la lista usable
si C1 = C3 ∨ l ∨ C4 y C2 = C5 ∨ ¯
l ∨ C6 entonces
si C3 ∨ C4 ∨ C5 ∨ C6 = entonces retorne “lo pude demostrar”
si no existe C7 ∈ usable ∪ sos que subsume a C3 ∨ C4 ∨ C5 ∨ C6 y
C3 ∨ C4 ∨ C5 ∨ C6 no es una tautologı́a entonces
elimine todo C8 ∈ usable ∪ sos subsumido por C3 ∨ C4 ∨ C5 ∨ C6
sos := sos ∪ {C3 ∨ C4 ∨ C5 ∨ C6 }
33