Como uso o pedido canônico para reduzir a simetria na codificação SAT do problema do buraco de pombo?

No artigo "Codificação eficiente de CNF para selecionar 1 de N objetos", os autores apresentam sua técnica de "variável de comando" para codificar a restrição e depois falam sobre o problema do buraco de pombo.

Como meu erro pode existir no entendimento de nível inferior, deixe-me declarar o que acho que sei antes de fazer a pergunta:

Seja e o número de pombos e buracos. A codificação ingénuo utiliza uma variável proposicional que é verdadeiro quando o pombo é para ser colocado na furo. A cláusula $m$ $n$ $X_{i,j}$ $i'th$ $j'th$ $ExactlyOne(X_{1,1}, X_{1,2}, ..., X_{1,n})$ reforça que o pombo 1 deve ocupar exatamente um buraco; cláusulas idênticas são adicionadas para os outros pombos. A cláusula Impõe que não mais do que um pombo ocupa um orifício; cláusulas idênticas são adicionadas para os orifícios restantes. $AtMostOne(X_{1,1}, X_{2,1}, ..., X_{m,1})$

Quando há mais pombos do que buracos (m> n), o problema é insolúvel (óbvio para os seres humanos), mas o solucionador SAT não "vê" esse fato. Quando ele não pode encontrar uma maneira de colocar pombos ele irá procurar uma tentativa com pombos . Não entende que a ordem dos pombos é irrelevante. O artigo, entre outros, chama isso de simetria. $1,2,3,..,m$ $2,1,3,...,m$

Instâncias em que são usadas como um teste extenuante da capacidade de um solucionador SAT de detectar insatisfação. $m=n+1$

O artigo propõe quebrar a simetria impondo ordem aos pombos. O pombo deve ser colocado em um buraco na frente do buraco do pombo (ou seja, o pombo no buraco deve ter um número menor que o do pombo no buraco ). Em seguida, ele diz decepcionantemente: "Devido a limitações de espaço, não descrevemos explicitamente em detalhes a codificação de ordem canônica, mas o número de cláusulas geradas é da ordem ". $i$ $i+1$ $j$ $j+1$ $O(n*log(n))$

Então, minha pergunta é: o que eles fizeram para obter esses resultados?

Quero tratar as variáveis como uma sequência de bits que, numericamente, identifica a escolha de qual pombo entrou no buraco 1 e assim por diante. Siga isso com comparadores para reforçar a sugestão do artigo. Minha construção ingênua de comparador, no entanto, exige cláusulas m, uma para cada bit (de tamanho cada vez mais feio). Socorro! :) $\{X_{1,1}, X_{2,1}, ..., X_{m,1}\}$ $n-1$

cc.complexity-theory sat proof-complexity

— Andrew Lamoureux
fonte

Seja o número de pombos seja o número de buracos. Deixe as variáveis proposicional ... codificam a representação binária de , se o th pombo é colocado na th furo. (Exemplo, se o pombo 1 fosse colocado no buraco 10, , que é o binário 1001. Então, = verdadeiro, $m$ $n$ $B_{i,0}$ $B_{i,log(n)}$ $j-1$ $i$ $j$ $j - 1 = 9$ $B_{1,3}$ $B_{1,2}$ = falso, = falso e = verdadeiro.) $B_{1,1}$ $B_{1,0}$

Aplique uma ordem específica dos pombos nos orifícios, exigindo que o orifício codificado pelas variáveis seja menor que o de . As codificações são comparadas conforme o esperado: $B_{i}$ $B_{i+1}$

< OU = E < $B_{i,log(n)}$ $B_{i+1,log(n)}$

$B_{i,log(n)}$ $B_{i+1,log(n)}$ $B_{i,log(n)-1}$ OU = AND = e $B_{i+1,log(n)-1}$

$B_{i,log(n)}$ $B_{i+1,log(n)}$ $B_{i,log(n)-1}$ $B_{i+1,log(n)-1}$ < OR ... $B_{i,log(n)-2}$ $B_{i+1,log(n)-2}$

... seguindo o padrão de permitir que os bits mais significativos sejam equivalentes desde que o próximo bit à direita seja menor que o do próximo pombo. Haverá conjunção por comparador e comparadores, dando o esperado cláusulas adicionais. $O(log(n))$ $O(m)$ $O(m * log(n))$

Os valores da variável devem estar implícitos nos valores . Cada pouco está implícito por qualquer um de um conjunto particular de o variáveis sendo conjunto. Exemplo: supondo que , você teria: $B$ $X_{i,j}$ $B_{i,*}$ $X_{i,j}$ $n = 16$

$ExactlyOne(X_{1,9}, X_{1,10}, X_{1,11}, X_{1,12}, X_{1,13}, X_{1,14}, X_{1,15}, X_{1,16}, \overline{B_{1,3}})$

o que força verdadeiro se o pombo 1 for colocado em qualquer um dos orifícios 9-16. Caso contrário, é definido como falso para satisfazer a cláusula. Estas cláusulas definir os restantes pedaços. $B_{1,3}$ $B_{1,3}$ $B_{i}$

$ExactlyOne(X_{1,5}, X_{1,6}, X_{1,7}, X_{1,8}, X_{1,13}, X_{1,14}, X_{1,15}, X_{1,16}, \overline{B_{1,2}})$ $ExactlyOne(X_{1,3}, X_{1,4}, X_{1,7}, X_{1,8}, X_{1,11}, X_{1,12}, X_{1,15}, X_{1,16}, \overline{B_{1,1}})$ $ExactlyOne(X_{1,2}, X_{1,4}, X_{1,6}, X_{1,8}, X_{1,10}, X_{1,12}, X_{1,14}, X_{1,16}, \overline{B_{1,0}})$

$log(n)$ $m$ $m * log(n)$

— Kyle Jones
fonte

X_{1, 10} \to B_{1, 3} \land \bar{B_{1, 2}} \land \bar{B_{1, 1}} \land B_{1, 0}

$X_{1,10} \to B_{1,3} \land \overline{B_{1,2}} \land \overline{B_{1,1}} \land B_{1,0}$

l o g (n)

$log(n)$

X_{i, j}

$X_{i,j}$

m * n

$m*n$

Vou editar a resposta para resolver isso.

— precisa

E x a c t l y O n e ()

$ExactlyOne()$