Um algoritmo experimental de satisfação

Não se acredita que a satisfação geral (com algumas exceções, como Cláusulas de Horn), tenha uma solução algorítmica. No entanto, o algoritmo a seguir parece ser uma solução para satisfação geral. Qual é exatamente a falha com o seguinte algoritmo?

Deixei $W$ seja um conjunto vazio que conterá todas as variáveis que necessariamente precisam ser verdadeiras ou falsas.
Deixei $L$ ser o conjunto de cláusulas.
Repetir $L$ .
Sempre que uma variável não condicional ^† for encontrada, remova-a de $L$ e insira-o $W$ .
Se isso deixar uma implicação AND vazia ^‡ , remova todas as variáveis nessa implicação vazia de $L$ e insira no $W$ .
Se isso deixar uma implicação OR vazia ^‡ , crie novas instâncias do algoritmo, onde cada instância lida com uma variável na implicação (ou seja, se a implicação for: $x V \implies y$ , crie uma instância em que $x$ é inserido em $W$ um onde $y$ é inserido em $W$ e um onde $x$ e $y$ são inseridos em $W$ )
Defina todas as variáveis em $W$ para o valor que eles necessariamente têm que ser.
Reinsira as variáveis em $W$ no $L$ com seus valores alterados e verifique se todas as cláusulas foram atendidas.
Se a satisfação for alcançada, retorne $L$ , caso contrário, retorne "Não satisfeito".

^† Uma variável não condicional é definida como uma variável necessária verdadeira ou falsa, por exemplo $\implies x$ ou $\implies \neg y$ .

^‡ Uma implicação vazia é definida como uma implicação em que um lado está vazio (por exemplo, $\implies x \wedge y$ ) ou o outro lado é necessariamente verdadeiro (por exemplo, $\mathrm{true} \vee a \implies b$ .

Para obter uma compreensão mais intuitiva do algoritmo, considere o seguinte 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}$

O algoritmo fará o seguinte:

1) Desde $c$ , $f$ , $g$ são variáveis não condicionais, o algoritmo irá inseri-las em $W$ . $W = \{c, f, g\}$ .

2) Remoção $c$ , $f$ e $g$ deixará as cláusulas vazias: $\implies \neg a, a \wedge b, b$ . Estes serão adicionados a $W$ . $W = \{c, f, g, b, \neg a\}$ .

3) Reinserir as variáveis em $L$ resultará na violação das primeiras cláusulas: $a \wedge b \implies c$ . Desde a $a$ é falso, $c$ é falso, significando que a cláusula (v) é violada. O algoritmo retornará "Incompatível"

Estou ciente de que o algoritmo parece confuso. Por favor, não hesite em pedir esclarecimentos.

A partir dos comentários, agora percebo que não existe um algoritmo de satisfação geral eficiente e conhecido . Ainda estou interessado em comentários sobre o meu algoritmo. Funciona? Como ele se compara com algoritmos comuns?

— Gilles 'SO- parar de ser mau'
fonte

O que faz você pensar que não há solução algorítmica para a satisfação geral? Existem algoritmos para fazer isso; nenhum deles é conhecido por ter tempos de execução polinomiais de pior caso. O que você está descrevendo parece um conhecido algoritmo de satisfação baseado em resolução.

— templatetypedef

@templatetypedef O artigo da Wikipedia parecia sugerir que não existe solução. Por acaso você poderia me referir ao conhecido algoritmo?

@Riddler o que o artigo da Wikipedia realmente diz é "SAT foi o primeiro exemplo conhecido de um problema de NP-completo. Isso significa brevemente que não há algoritmo conhecido que resolva com eficiência todas as instâncias de SAT" Ele também possui um "Algoritmos para resolver SAT" seção.

Definitivamente, existem soluções algorítmicas para a satisfação geral, pois existem soluções de força bruta (atribuindo todas as combinações de valores True / False às variáveis e verificando se alguma das expressões resultantes é avaliada como True).

O problema é que você gera um número exponencial de novas instâncias das ORs vazias, na pior das hipóteses.

— Elliot Gorokhovsky,

Respostas:

Problema 1

O caso de $(x\rightarrow y \vee \overline y)$ deve ser uma "variável não condicional" em relação a $x$ (ou seja, que $\overline x$ agora deve ser inserido no $W$ ) Se isso não for verdade, seu algoritmo precisará de uma etapa extra para inferir isso. Assumindo $(x\rightarrow y \vee \overline y)$ é uma " variável não condicional ", continuamos.

Problema 2

NOTA: esse é um problema que eu notei; pode muito bem haver outros problemas.

O problema está com a " implicação OR vazia " dividida em dois algoritmos, é que, na sua forma atual, a divisão não cobre todos os casos. Em particular:

Você começa com $(x \vee c \rightarrow y)$ , então $c$ é removido e ficamos com uma implicação OU vazia de $(x \vee [] \rightarrow y)$ . Você sugere agora dividi-lo em dois novos problemas e resolver cada um deles; Um com $x=T\wedge y=T$ e um onde $y=T$ . Mas isso não cobre todos os casos. E o caso quando $x=F\vee y=F$ . No entanto, seu algoritmo nunca considera a possibilidade de $y$ é falso.

Eu acho que você pode consertar isso formulando os dois novos problemas como um com $y$ e um com $\overline x$ .

Problema 3

O que acontece quando você fica com várias cláusulas no formulário:

(a \land b \to c)

$(a\wedge b \rightarrow c)$

(a \to b \lor c)

$(a \rightarrow b \vee c)$

Depois de reduzir tudo, essas cláusulas permanecerão e você não poderá testar sua satisfação facilmente.

Análise

Nota : Esta notação "O", $\mathcal{O}(something)$ etc., é chamado de Big O notação . $\Omega(something)$ é chamado Big-ômega.

Supondo que o algoritmo funcionasse em geral, ele seria executado no tempo de $\Omega(2^m)$ pior caso, $m$ sendo o número de variáveis. O motivo é que cada divisão do problema em problemas de tamanho semelhante significa que o algoritmo é executado em tempo exponencial. Para visualizar esse conceito, observe a seguinte imagem de uma árvore binária completa (imagem daqui ):

diagrama da árvore binária completa

Agora imagine que o problema original é o nó no topo. Dividimos o problema em dois problemas no segundo nível, mas eles são de tamanho semelhante (apenas nos livramos de uma variável, $x$ ou $y$ da implicação OR vazia , portanto, ainda teremos muitas implicações OR vazias para executar cada nível). Teremos que dividir o problema $\mathcal{O}(m)$ vezes para se livrar de $m$ variáveis. Isso significa que teremos que lidar com uma árvore com $m$ níveis. Uma árvore com $m$ níveis tem $2^m$ nós de folha (nós na parte inferior). Isso é chamado tempo exponencial e é informalmente um tanto parecido com todos os algoritmos de satisfação booleanos conhecidos. Mas o mesmo acontece com a força bruta: existem $2^m$ possíveis atribuições das variáveis; portanto, com força bruta, você pode adivinhar cada tarefa e verificar a satisfação com desempenho semelhante!

— Realz Slaw
fonte

Eu acho que você quer dizer

Ω (.)

$\Omega(.)$ ?

— Raphael

TBH não tenho certeza se

Ω

$\Omega$ é apropriado, porque, na melhor das hipóteses, o algoritmo pode ser resolvido rapidamente. O que eu quis dizer foi que o limite superior era pior do que (ou pelo menos tão ruim quanto)

O (2^{m})

$\mathcal{O}(2^m)$ . Não sei a maneira correta de afirmar isso. O ponto principal da notação O, porém, é livrar-nos das constantes. Se houver uma maneira melhor de expressá-lo, fique à vontade para editar.

— Realz Slaw

Isso pode ser expresso como "o pior caso é

Ω (2^{m})

$\Omega(2^m)$ "?

— Realz Slaw

Depois de qualificar o "pior caso", é disso que falamos, sem o melhor caso envolvido. "pior que

O (.)

$O(.)$ "(seja o que for" pior que esse limite superior "significa) é realmente o que

Ω (.)

$\Omega(.)$ (um limite inferior) diz; veja também aqui . Nesse caso, o pior tempo de execução em

Ω (2^{m})

$\Omega(2^m)$ Parece ser o que você quer dizer. Da mesma forma, você quer

Θ (m)

$\Theta(m)$ ou

Ω (m)

$\Omega(m)$ no último parágrafo.

— Raphael

-5

Antes de sentir que possui um "novo" algoritmo SAT, revise o algoritmo padrão / clássico de retorno / pesquisa na literatura para o problema que data de ~ 1962, o algoritmo Davis – Putnam – Logemann – Loveland . a maioria dos algoritmos de retorno / recursividade para o problema provavelmente acabará parecendo um pouco semelhante a esse algoritmo, embora possa demorar um pouco para demonstrar essa equivalência.

A análise séria envolveria a comparação do seu algoritmo com exemplos (ou instâncias aleatórias) vs DPLL.

E, portanto, é útil apenas resumir como o algoritmo difere dele. sem revisar seu código, as chances são de:

O algoritmo possui um bug. retornando falsos positivos ou negativos (isto é, o algoritmo retorna "a fórmula é satisfatória" quando não é ou vice-versa, respectivamente). isso geralmente pode ser detectado por testes minuciosos de uma grande variedade de fórmulas geradas aleatoriamente e por comparação com outro algoritmo / implementação correto conhecido, por exemplo, DPLL.
Seu algoritmo não é tão bom quanto o DPLL.
Se é tão bom quanto DPLL ou "melhor", geralmente se deve a heurísticas / estratégias de ramificação e seleção de variáveis e à distribuição de instâncias em teste.

O algoritmo pode ser facilmente entendido por um graduado inteligente, no entanto, raramente parece ser ensinado no nível de graduação ou em livros didáticos de graduação, ou talvez nem mesmo frequentemente referenciado, possivelmente levando a uma visão ou impressão equivocada de que os algoritmos básicos de SAT não são bem compreendidos etc.

Recentemente, recentemente, deparei com este site "ao vivo" chamado ToughSat de Yuen e Bebel para gerar instâncias rígidas para uso com benchmarking, algumas baseadas em fatoração [um dos métodos clássicos de geração de instâncias SAT]. existem outros, por exemplo, DIMACs que armazenam arquivos de instâncias rígidas, embora ele não esteja mais online.

— vzn
fonte