Qual é a maneira mais rápida de verificar a inclusão de conjuntos?

Dados $n$ subconjuntos $S_1,\ldots,S_n$ de $\{1,\ldots,d\}$ .

$S_i,S_j$$S_i \subsetneq S_j$

A solução trivial para esse problema passa por todos os pares de conjuntos e verifica a inclusão de um par no tempo , portanto, o tempo de execução geral é . Esse problema pode ser resolvido mais rapidamente? Existe um nome para isso na literatura?$O(d)$$O(n^2 d)$

Você não pode resolvê-lo no tempo $O(n^{2-\epsilon})$ para qualquer constante $\epsilon>0$ , a menos que a Hipótese do Tempo Exponencial Forte seja falsa.

Ou seja, se tivéssemos um algoritmo tal, nós poderia resolver $n$ -variável CNF satisfabilidade em $O((2-\epsilon')^{n})$ tempo para alguns $\epsilon'>0$ . O motivo é que poderíamos dividir as variáveis ​​em duas partes iguais $P_1$ e $P_2$ de $n/2$ variáveis ​​cada. Para cada parte, construímos uma família $F_1$ e $F_2$ respectivamente, de subconjuntos das cláusulas da seguinte maneira. Para cada atribuição, adicionamos um subconjunto que consiste nas cláusulas não satisfeitas pela atribuição. Essa construção é executada no tempo $poly(n)2^{n/2}$ .

Para finalizar a construção, observamos que a instância CNF original tem uma solução se houver um subconjunto em $F_1$ que não esteja associado a algum subconjunto em F_2$F_2$ .

Adicionando alguns elementos extras ao seu conjunto de base, além dos de cada cláusula, não é muito difícil incorporar esse problema de disjunção como uma questão de inclusão de conjunto. Você basicamente aceita os complementos dos subconjuntos em . Para garantir que dois conjuntos em não sejam contados como uma inclusão, adicione um código de uma anti-cadeia aos elementos extras. Outro código anti-cadeia (em outros elementos extras do conjunto de referência) é usado nos subconjuntos de para garantir que nenhum par de subconjuntos de uma inclusão. Finalmente, todos os conjuntos formados a partir de incluem todos os elementos dos anti-cadeia de .F 1 F 2 F 2 F 1 F $F_1$$F_1$$F_2$$F_2$$F_1$$F_2$

Esta é uma pergunta de inclusão de conjuntos em subconjuntos em um conjunto de bases . O argumento basicamente remonta a um artigo anterior de Ryan Williams (não me lembro qual). d = p o l y ( n $2^{n/2+1}$$d=poly(n)$

Se você estiver interessado em definir famílias com , uma outra solução conceitualmente muito semelhante à descrita na resposta de Yuval é calcular a transformação zeta$n = \omega(2^{d/2})$

$$f\zeta(T) = \sum_{S \subseteq T} f(S)\,,$$

onde é a função indicadora da família de entrada . Isto é, se e de outro modo. Claramente, existem conjuntos tais que se e somente se para alguns .F = { S 1 , S 2 , ... , S n } f ( S ) = 1 S ∈ F f ( S ) = 0 S i$f \colon 2^{[d]} \to \mathbb{R}$$\mathcal{F} = \{ S_1, S_2, \dotsc, S_n \}$$f(S) = 1$$S \in \mathcal{F}$$f(S) = 0$S i ⊆ S j f ζ ( S ) > 1 S ∈ $S_i \not= S_j$$S_i \subseteq S_j$$f\zeta(S) > 1$$S \in \mathcal{F}$

A transformada zeta pode ser calculada no tempo usando o algoritmo de Yates, veja, por exemplo, TAOCP de Knuth, vol. 2, §4.6.4. O algoritmo em si é uma programação dinâmica bastante direta e é fácil modificá-lo para dar um exemplo de um conjunto incluído, se houver.$O(d2^d)$

Esse problema pode ser resolvido usando um algoritmo para multiplicação rápida de matrizes, e eu também suspeito que seja equivalente computacionalmente à multiplicação de matrizes (embora eu não conheça nenhuma maneira de provar isso e não pense que existem técnicas para provar isso) ) Essa solução teria um tempo de execução de O (n ^ {2.373}) quando n = d e outros tempos de execução para outras relações entre d e n.

Aqui está como você o resolve usando a multiplicação de matrizes: Você escreve os vetores característicos dos conjuntos nas linhas de uma matriz n por d A e os vetores característicos dos complementos dos conjuntos nas colunas de anúncio pela matriz n. multiplique A por B. Os pares de conjuntos que se cruzam são exatamente os locais do produto A * B que são iguais a zero.

Para obter o melhor tempo de execução conhecido para esse problema, consulte o artigo de Huang e Pan sobre o assunto. Se bem me lembro, quando d se torna grande o suficiente, o tempo de execução se tornará o obviamente ótimo (nd). Para n = d, você terá um tempo de execução de O (n ^ {2.373}). Para outras relações de n e d, você obterá outros valores. Se existir um algoritmo ideal para multiplicação de matriz retangular, você obterá um algoritmo com tempo de execução O (n ^ 2 + nd) para o seu problema. Suspeito que não exista uma maneira melhor do que essa para solucionar seu problema, mas estou longe de ter certeza.

Essa solução provavelmente não é útil, pois as constantes desses algoritmos são muito grandes. O algoritmo de Strassen pode melhorar a solução ingênua para valores razoáveis ​​de n e d, mas nem tenho certeza disso. No entanto, problemas que parecem tão relacionados à multiplicação de matrizes raramente têm algoritmos combinatórios melhores que o algoritmo ingênuo (por mais de fatores polilogarítmicos); portanto, se eu tivesse que adivinhar, acho que não há um bom algoritmo para o seu problema que é significativamente melhor que o ingênuo, usando as técnicas atuais.

Se , sabemos que o conjunto não é um antichain pelo lema de Sperner, e assim o versão de decisão do problema se torna trivial. Mas pode ser interessante considerar o caso em que é próximo desse valor.$n > \binom{d}{d/2} \approx \frac{2^d}{\sqrt{\pi d/2}}$$n$

O trabalho de Friedgut no teorema de Erdős-Ko-Rado mostra que, dado o vetor característico de uma família de subconjuntos de , pode-se encontrar no tempo se é uma família que se cruza (a cada dois elementos de interseção). De maneira mais geral, seu método permite calcular que é uma função conhecida (específica) que não é zere somente se forem disjuntos. depende apenas do histograma de , onde é o indicador de .$f$$[m]$$O(m2^m)$$f$$f$

$$\Sigma = \sum_{x,y \in f} S(x,y),$$ $S(x,y) \geq 0$$x,y$$S(x,y)$$\{(x_i,y_i) : i \in [d]\}$$x_i$$i \in x$

(Como um aparte, comentamos que seu método também funciona se recebermos duas famílias , e estivermos interessados ​​em . Nos dois casos, precisamos calcular as transformadas de Fourier-Walsh enviesadas de para um arbitrário e, em seguida, , em que depende apenas do peso de Hamming de .)$f,g$$\Sigma = \sum_{x\in f, y\in g} S(x,y)$$p$$f,g$$p \in (0,1/2)$$\Sigma = \sum_x T(x) \hat{f}(x) \hat{g}(x)$$T(x)$$x$

Como tudo isso se relaciona com o problema em questão? Considere a família Todo é separado de todos os . Como é dado explicitamente, podemos calcular a contribuição desses pares para . Existem mais pares disjuntos? Se estiver separado de então e, portanto, . Então é um antichain iff

$$F = \{ S_i \cup \{x\} : i \in [n] \} \cup \{ \overline{S_i} \cup \{y\} : i \in [n] \}.$$ $S_i \cup \{x\}$$\overline{S_i} \cup \{y\}$$S(x,y)$$\Sigma$$S_i \cup \{x\}$$\overline{S_j} \cup \{y\}$$S_i \cap \overline{S_j} = \emptyset$$S_i \subseteq S_j$$S_1,\ldots,S_n$ $$\Sigma = \sum_{i=1}^n S(S_i \cup \{x\}, \overline{S_i} \cup \{y\}).$$

Esse algoritmo é executado no tempo , ignorando os fatores polinomiais em . Quando está próximo de , isso é significativamente melhor que . Em geral, obtemos uma melhoria desde que .d$\tilde{O}(n + 2^d)$$d$$n$$2^d$$\tilde{O}(n^2)$$n = \omega(2^{d/2})$

Dado que sabemos que existe um par satisfazendo , como o encontramos? Suponha que todos os conjuntos em dois grupos aleatoriamente. Com probabilidade aproximadamente , os conjuntos e vão encontrar-se no mesmo grupo. Se estamos tão sorte, podemos executar nosso algoritmo em e , encontrar em que se fazem estes pertencem a, e assim reduzir pela metade o número de conjuntos que temos de considerar. Caso contrário, podemos tentar novamente. Isso mostra que, com um número esperado de chamadas oracle para a versão de decisão, podemos realmente encontrar um par que satisfaça .S 1 , ... , S n L 1 , L 2 1 / 2 S $S_i \subseteq S_j$$S_1,\ldots,S_n$$G_1,G_2$$1/2$$S_i$$S_j$$G_1$$G_2$$O(\log n)$$S_i \subseteq S_j$

Também podemos derandomizar o algoritmo. Sem perda de generalidade, suponha que . Em cada etapa, particionamos de acordo com cada um dos bits. Uma dessas partições sempre colocará e na mesma parte, a menos que tenham polaridades opostas; podemos testar isso explicitamente usando apenas operações . Isso fornece um algoritmo determinístico usando chamadas oracle para a versão de decisão. k x y O ( n d ) O ( log 2 n $n = 2^k$$k$$x$$y$$O(nd)$$O(\log^2 n)$