Un algoritmo tentativo de satisfacción

No se cree que la satisfacción general (con algunas excepciones, como las cláusulas Horn) tenga una solución algorítmica. Sin embargo, el siguiente algoritmo parece ser una solución para la satisfacción general. ¿Cuál es exactamente la falla con el siguiente algoritmo?

Sea un conjunto vacío que contendrá todas las variables que necesariamente tienen que ser verdaderas o falsas. $W$
Sea el conjunto de cláusulas. $L$
Loop a través de . $L$
Cada vez que una variable no condicional ^† se encuentra, sacarlo de e insertarlo en . $L$ $W$
Si esto deja un vacío y la implicación ^‡ , eliminar todas las variables en esa implicación vacío de y se insertan en . $L$ $W$
Si esto deja una implicación OR vacía ^‡ , cree nuevas instancias del algoritmo, donde cada instancia trate con una variable en la implicación (es decir, si la implicación es: , cree una instancia donde se inserte en , uno donde se inserta en y uno donde e se insertan en ). $x V \implies y$ $x$ $W$ $y$ $W$ $x$ $y$ $W$
Establezca todas las variables en en el valor que necesariamente tienen que ser. $W$
Vuelva a insertar las variables en en con sus valores modificados y compruebe si se cumplen todas las cláusulas. $W$ $L$
Si se cumple con la satisfacción, devuelva , de lo contrario devuelva "No satisfecho". $L$

^† Una variable no condicional se define como una variable que es necesaria verdadera o falsa, por ejemplo, o . $\implies x$ $\implies \neg y$

^‡ Una implicación vacía se define como una implicación en la que un lado está vacío (por ejemplo, ) o el otro lado es necesariamente verdadero (por ejemplo, . $\implies x \wedge y$ $\mathrm{true} \vee a \implies b$

Para obtener una comprensión más intuitiva del algoritmo, considere el siguiente conjunto de cláusulas : $L$

\begin{aligned} a \land b & ⟹ c & (i) \\ ⟹ f \land g & (ii) \\ f & ⟹ \neg a & (iii) \\ f \lor a & ⟹ b & (iv) \\ ⟹ c & (v) \end{aligned}

$\begin{align} a \wedge b &\implies c & \text{(i)} \\ &\implies f \wedge g & \text{(ii)} \\ f &\implies \neg a & \text{(iii)} \\ f \vee a &\implies b & \text{(iv)} \\ &\implies c & \text{(v)} \\ \end{align}$

El algoritmo hará lo siguiente:

1) Puesto que , , son variables no condicionales, el algoritmo insertarlos en . . $c$ $f$ $g$ $W$ $W = \{c, f, g\}$

2) Extracción de , y saldrán de las cláusulas vacíos: . Estos se añaden a . . $c$ $f$ $g$ $\implies \neg a, a \wedge b, b$ $W$ $W = \{c, f, g, b, \neg a\}$

3) Reinsertar las variables en dará como resultado la violación de las primeras cláusulas: . Como es falso, es falso, lo que significa que se viola la cláusula (v). El algoritmo devolverá "No satisfecho" $L$ $a \wedge b \implies c$ $a$ $c$

Soy consciente de que el algoritmo parece confuso. Por favor, siéntase libre de pedir una aclaración.

De los comentarios ahora me doy cuenta de que no se conoce un algoritmo de satisfacción general eficiente eficiente . Todavía estoy interesado en comentarios sobre mi algoritmo. ¿Funciona? ¿Cómo se compara con los algoritmos comunes?

— Gilles 'SO- deja de ser malvado'
fuente

¿Qué te hace pensar que no hay una solución algorítmica para la satisfacción general? Absolutamente hay algoritmos para hacer esto; Sin embargo, ninguno de ellos tiene el peor tiempo de ejecución polinómico. Lo que está describiendo parece un conocido algoritmo de satisfacción basado en la resolución.

— templatetypedef

@templatetypedef El artículo de Wikipedia parece sugerir que no existe una solución. ¿Por casualidad podrías referirme al conocido algoritmo?

@Riddler lo que el artículo de Wikipedia dice en realidad es "SAT fue el primer ejemplo conocido de un problema de NP completo. Eso significa brevemente que no existe un algoritmo conocido que resuelva eficientemente todas las instancias de SAT". También tiene un "Algoritmo para resolver SAT" sección.

Definitivamente, existen soluciones algorítmicas para la satisfacción general, ya que existen soluciones de fuerza bruta (asignar todas las combinaciones de valores Verdadero / Falso a las variables y ver si alguna de las expresiones resultantes se evalúa como Verdadero).

El problema es que genera un número exponencial de nuevas instancias a partir de los OR vacíos en el peor de los casos.

— Elliot Gorokhovsky

Respuestas:

Problema 1

El caso de debería ser una "variable no condicional" con respecto a (es decir, que ahora debería insertarse en ). Si esto no es cierto, entonces su algoritmo necesita un paso adicional para inferir esto. Suponiendo que es una " variable no condicional ", continuamos. $(x\rightarrow y \vee \overline y)$ $x$ $\overline x$ $W$ $(x\rightarrow y \vee \overline y)$

Problema 2

NOTA: este es un problema que noté; puede muy bien haber otros problemas.

El problema es que la " implicación OR vacía " se divide en dos algoritmos, es que en su forma actual, la división no cubre todos los casos. En particular:

Comienza con , luego se quita y nos queda con una implicación OR vacía de . Sugiere ahora dividirlo en dos problemas nuevos y resolver cada uno de ellos; uno con y uno donde . Pero esto no cubre todos los casos. ¿Qué pasa con el caso cuando . Sin embargo, su algoritmo nunca considera la posibilidad de que sea falso. $(x \vee c \rightarrow y)$ $c$ $(x \vee [] \rightarrow y)$ $x=T\wedge y=T$ $y=T$ $x=F\vee y=F$ $y$

Creo que podría solucionarlo formulando los dos nuevos problemas como uno con y otro con . $y$ $\overline x$

Problema 3

Qué sucede cuando te quedan un montón de cláusulas en el formulario:

(a \land b \to c)

$(a\wedge b \rightarrow c)$

(a \to b \lor c)

$(a \rightarrow b \vee c)$

Después de reducir todo, estas cláusulas permanecerán y no podrá probar su satisfacción fácilmente.

Análisis

Nota : Esta notación "O", , etc., se llama Big O notación . se llama Big-omega. $\mathcal{O}(something)$ $\Omega(something)$

Suponiendo que el algoritmo funcionara en general, se ejecutaría en el tiempo del peor caso de , siendo el número de variables. La razón es que cada división del problema en problemas de tamaño similar significa que el algoritmo se ejecuta en tiempo exponencial. Para visualizar este concepto, mire la siguiente imagen de un árbol binario completo (imagen de aquí ): $\Omega(2^m)$ $m$

diagrama del árbol binario completo

Ahora imagine que el problema original es el nodo en la parte superior. Dividimos el problema en dos problemas en el segundo nivel, pero son de un tamaño similar (solo eliminamos una variable, o de la implicación OR vacía , por lo que todavía tendremos muchas implicaciones OR vacías para hacer cada una nivel). Potencialmente tendremos que dividir el problema veces para deshacernos de las variables . Esto significa que tendremos que lidiar con un árbol con niveles. Un árbol con niveles tiene nodos de hoja $x$ $y$ $\mathcal{O}(m)$ $m$ $m$ $m$ $2^m$ (nodos en la parte inferior). Esto se llama tiempo exponencial y, de manera informal, está a la par con todos los algoritmos de satisfacción booleana conocidos. Pero también lo es la fuerza bruta: hay posibles asignaciones de las variables, por lo que por la fuerza bruta puede adivinar cada asignación y verificar la satisfacción con un rendimiento similar. $2^m$

— Ensalada Realz
fuente

Supongo que te refieres a ?

Ω (.)

$\Omega(.)$

— Raphael

TBH No estoy seguro de si es apropiado, porque en el mejor de los casos, el algoritmo se puede resolver rápidamente. Lo que quise decir fue que el límite superior era peor que (o al menos tan malo como) . No sé la forma correcta de decir esto. Sin embargo, el punto principal de la notación O es librarnos de las constantes. Si hay una mejor manera de expresarlo, siéntase libre de editar.

Ω

$\Omega$

O (2^{m})

$\mathcal{O}(2^m)$

— Realz Slaw

¿Se puede expresar esto como "el peor de los casos es "?

Ω (2^{m})

$\Omega(2^m)$

— Realz Slaw

Una vez que califique como "el peor de los casos", esto es de lo que hablamos, no se trata del mejor de los casos. "peor que " (lo que sea que significa "peor que este límite superior") es lo que dice (un límite inferior); ver también aquí . En este caso, el peor tiempo de ejecución en parece ser lo que quieres decir. Del mismo modo, desea u en el último párrafo.

O (.)

$O(.)$

Ω (.)

$\Omega(.)$

Ω (2^{m})

$\Omega(2^m)$

Θ (m)

$\Theta(m)$

Ω (m)

$\Omega(m)$

— Raphael

-5

Antes de sentir que tiene un "nuevo" algoritmo SAT, revise el algoritmo de rastreo / búsqueda estándar / clásico en la literatura para el problema que data de ~ 1962, el algoritmo Davis-Putnam-Logemann-Loveland . La mayoría de los algoritmos de retroceso / recursivo para el problema probablemente terminarán pareciéndose a este algoritmo, aunque puede llevar bastante tiempo demostrar esta equivalencia.

Un análisis serio implicaría comparar su algoritmo con ejemplos (o instancias aleatorias) frente a DPLL.

Por lo tanto, es útil simplemente resumir cómo su algoritmo difiere de él. sin revisar su código, las probabilidades son:

El algoritmo tiene un error. ya sea devolviendo falsos positivos o negativos (es decir, el algoritmo devuelve "la fórmula es satisfactoria" cuando no lo es o viceversa, respectivamente). esto generalmente se puede detectar mediante pruebas muy exhaustivas de una amplia gama de fórmulas generadas aleatoriamente y comprobando otro algoritmo / implementación correcto conocido, por ejemplo, DPLL.
Su algoritmo no es tan bueno como DPLL.
Si es tan bueno como DPLL o "mejor", generalmente se debe a las estrategias / heurísticas de selección de ramificaciones y variables y la distribución de instancias bajo prueba.

Un estudiante universitario inteligente puede entender fácilmente el algoritmo; sin embargo, parece que rara vez se enseña a nivel universitario o en libros de texto universitarios, o tal vez ni siquiera se hace referencia a menudo, lo que puede llevar a una visión o impresión errónea de que los algoritmos SAT básicos no se comprenden bien, etc.

También recientemente me encontré con este sitio "en vivo" llamado ToughSat por Yuen y Bebel por generar instancias difíciles para usar con benchmarking, algunas basadas en factoring [uno de los métodos clásicos de generación de instancias duras de SAT]. hay otros, por ejemplo, DIMAC que almacenan archivos de instancias difíciles aunque puede que ya no esté en línea.

— vzn
fuente