Codificando restrição 1-out-of-n para solucionadores SAT

Estou usando um solucionador SAT para codificar um problema e, como parte da instância SAT, tenho variáveis ​​booleanas onde se pretende que exatamente uma delas seja verdadeira e o restante seja falso . (Às vezes, isso é descrito como uma codificação "quente").$x_1,x_2,\dots,x_n$

Desejo codificar a restrição "exatamente um de deve ser verdadeiro" no SAT. Qual é a melhor maneira de codificar essa restrição, para fazer com que o solucionador SAT funcione da maneira mais eficiente possível?$x_1,\dots,x_n$

Eu posso ver muitas maneiras de codificar essa restrição:

• Restrições aos pares. Eu poderia adicionar restrições aos pares para todos para garantir que no máximo um seja verdadeiro e, em seguida, adicionar para garantir que pelo menos um seja verdadeiro . i , j x i x 1 ∨ x 2 ∨ ⋯ ∨ x $\neg x_i \lor \neg x_j$$i,j$$x_i$$x_1 \lor x_2 \lor \cdots \lor x_n$

  Isso adiciona cláusulas e nenhuma variável booleana extra.$\Theta(n^2)$

• Codificação binária. Eu poderia introduzir novas variáveis ​​booleanas para representar (em binário) um número inteiro tal que 1 \ le i \ le n (adicionando algumas restrições booleanas para garantir que eu está no intervalo desejado). Então, posso adicionar restrições que reforçam que x_i é uma árvore e que todos os outros x_j são falsos. Em outras palavras, para cada j , adicionamos cláusulas que reforçam que i = j \ Leftrightarrow x_j .i 1 , i 2 , … , i lg n i 1 ≤ i ≤ n i x i x j j i = j ⇔ x $\lg n$$i_1,i_2,\dots,i_{\lg n}$$i$$1 \le i \le n$$i$$x_i$$x_j$$j$$i=j \Leftrightarrow x_j$

  Isso adiciona cláusulas $\Theta(n \lg n)$ e não sei quantas variáveis ​​booleanas extras.

• Conte o número de valores verdadeiros. Eu poderia implementar uma árvore de circuitos somadores booleanos e exigir que , tratando cada como 0 ou 1 em vez de falso ou verdadeiro, e use a conversão Tseitin para converter o circuito em cláusulas SAT. Uma árvore de meio-somadores é suficiente: restrinja a saída de transporte de cada meio-somador a 0 e restrinja a saída final do meio-adicionador final na árvore a 1. A árvore pode ser escolhida para ter qualquer forma ( árvore binária equilibrada, ou desequilibrada, ou o que for).x $x_1+x_2+\dots+x_n=1$$x_i$

  Isso pode ser feito em portões e, assim, acrescenta cláusulas e novas variáveis booleanas.Θ ( n ) Θ ( n $\Theta(n)$$\Theta(n)$$\Theta(n)$

  Um caso especial dessa abordagem é a introdução de variáveis ​​booleanas , com a idéia de que deve conter o valor de x_1 \ lor x_2 \ lor \ cdots \ lor x_i . Essa intenção pode ser imposta adicionando as cláusulas y_i \ lor \ neg x_i , y_i \ lor \ neg y_ {i-1} e \ neg y_i \ lor x_i \ lor y_ {i-1} (onde tratamos y_0 como um sinônimo de false) para i = 1, \ dots, n . Em seguida, podemos adicionar as restrições \ neg y_i \ lor \ neg x_ {i + 1} para i = 1,2, \ dots, n-1 . Isso é basicamente equivalente à transformação de Tseitin de uma árvore de meio-somador, onde a árvore tem uma forma maximamente desequilibrada.y i x 1 ∨ x 2 ∨ ⋯ ∨ x i y i ∨ ¬ x i y i ∨ ¬ y i - 1 ¬ y i ∨ x i ∨ y i - 1 y 0 i = 1 , ... , n ¬ y i ∨ ¬ x i $y_1,\dots,y_n$$y_i$$x_1 \lor x_2 \lor \cdots \lor x_i$$y_i \lor \neg x_i$$y_i \lor \neg y_{i-1}$$\neg y_i \lor x_i \lor y_{i-1}$$y_0$$i=1,\dots,n$$\neg y_i \lor \neg x_{i+1}$$i=1,2,\dots,n-1$

• Rede de borboletas. Eu poderia construir uma rede de borboleta em bits, restringir a entrada de bits para ser , restringir a saída de bits para e tratar cada porta borboleta de 2 bits como uma porta independente que troca ou não troca sua entrada com a decisão de fazer isso com base em uma nova variável booleana nova que é deixada sem restrição. Então, posso aplicar a transformação Tseitin para converter o circuito em cláusulas SAT.$n$$n$$000\cdots 01$$n$$x_1 x_2 \cdots x_n$

  Isso requer portões e, assim, acrescenta cláusulas e novas variáveis booleanas.$\Theta(n \lg n)$$\Theta(n \lg n)$$\Theta(n \lg n)$

Existem outros métodos que negligenciei? Qual devo usar? Alguém já testou isso ou experimentou-os experimentalmente, ou alguém tem alguma experiência com algum desses? O número de cláusulas e / ou o número de novas variáveis ​​booleanas é uma boa métrica substituta para estimar o impacto disso no desempenho do solucionador SAT ou, se não, qual métrica você usaria?

Acabei de notar que esta resposta tem algumas referências sobre como impor restrições de cardinalidade para SAT, ou seja, impor a restrição de que exatamente das variáveis ​​são verdadeiras. Então, minha pergunta se resume a um caso especial em que . Talvez a literatura sobre restrições de cardinalidade ajude a esclarecer minha pergunta.$k$$n$$k=1$

Para o caso especial de k de n variáveis ​​verdadeiras em que k = 1, há uma codificação de variável de comando conforme descrito em Codificação eficiente de CNF para selecionar objetos de 1 a N por Klieber e Kwon. Simplificado: divida as variáveis ​​em pequenos grupos e adicione cláusulas que fazem com que o estado de uma variável comandante implique que um grupo de variáveis ​​seja todo falso ou todo, exceto um falso. Em seguida, aplique recursivamente o mesmo algoritmo às variáveis ​​de comando. No final do processo, exija que exatamente uma das poucas variáveis ​​do comandante final seja verdadeira. O resultado são O (n) novas cláusulas e O (n) novas variáveis.

Dada a onipresença de literais de dois assistidos em solucionadores baseados em DPLL, acho que o crescimento da cláusula O (n) é uma vantagem decisiva sobre os esquemas de codificação que adicionariam mais cláusulas.

Um artigo de Magnus Björk descreve duas técnicas que podem valer a pena tentar.

Para 1-fora-de- , pode-se utilizar tanto um-quente e codificação binária simultaneamente. Portanto, temos x 1 , … , x n como uma codificação de um ponto quente e y 1 , … , y b como uma codificação binária, em que b = lg n . Podemos codificar o "pelo menos um" restrição facilmente, num único cláusula: ( x 1 ∨ ⋯ ∨ x n ) . Também podemos forçar as duas codificações a serem consistentes com 2 lg $n$$x_1,\dots,x_n$$y_1,\dots,y_b$$b = \lg n$$(x_1 \lor \dots \lor x_n)$$2 \lg n$cláusulas: simplesmente adicionamos ou x $x_i \implies \neg y_j$ , de acordo com se o j- ésimo bit da codificação binária de i é 0 ou 1. Finalmente, a restrição "no máximo uma" segue automaticamente. Isso também permite que o restante da instância SAT use a codificação que for mais conveniente.$x_i \implies y_j$$j$$i$

Para -out-of- n , pode-se aplicar uma rede de classificação à entrada x 1 , … , x n para obter a saída classificada y 1 , … , y n e, em seguida, adicionar uma cláusula exigindo que y k seja verdadeiro e y k + 1 é falso. Existem várias redes de classificação simples que precisam apenas de unidades comparadoras de O ( n lg 2 n ) . Portanto, obtemos uma codificação que usa O ( n lg $k$$n$$x_1,\dots,x_n$$y_1,\dots,y_n$$y_k$$y_{k+1}$$O(n \lg^2 n)$ cláusulas e variáveis ​​temporárias.$O(n \lg^2 n)$

O papel é

Magnus Björk. Técnicas de codificação SAT bem-sucedidas . 25 de julho de 2009.

O artigo a seguir apresenta uma lista detalhada de codificações para 1-de- e k -de- n , com algumas avaliações experimentais de cada uma delas. As conclusões não são totalmente claras (a codificação do comando parece muito boa em seus experimentos).$n$$k$$n$

Alan M. Frisch, Paul A. Giannaros. Codificações SAT da restrição At-Most-k: algumas velhas, outras novas, outras rápidas, outras lentas . ModRef 2010.