Generalizações de pesquisa binária para posets?

Suponha que eu possua um poset "S" e um predicado monotônico "P" em S. Quero encontrar um ou todos os elementos máximos de S satisfazendo P.

EDIT : Estou interessado em minimizar o número de avaliações do P .

Quais algoritmos existem para esse problema e quais propriedades e operações adicionais eles exigem no S?

E os casos especiais importantes, como:

• S é uma ordem linear - então a pesquisa binária regular funciona, desde que você tenha uma operação "find middle"
• S é uma treliça
• S é uma rede de subconjuntos
• S é uma rede multiset
• ...

Os dois últimos casos parecem particularmente importantes, por exemplo, para o experimento - você tem um conjunto de parâmetros booleanos ou reais e deseja encontrar a menor combinação possível deles que reproduza um padrão específico (por exemplo, um teste que falhou).

Não pensei muito nisso, por favor, corrija-me se estiver errado.

Digamos que é a largura do poset.$w$

1. Para o poset que é a união de cadeias disjuntas, você precisa de pelo menos w log n avaliações de P aplicando apenas o limite inferior padrão na complexidade da consulta da pesquisa binária em cada cadeia.$w$$w\log n$$P$

2. Como você faz comparações gratuitamente, é possível calcular uma decomposição em cadeia do poset em cadeias gratuitamente. Fazer busca binária em cada cadeia para identificar o primeiro elemento que satisfaz P . Depois, revise os elementos identificados e remova os dominados. O número de avaliações de P é O ( w log n ) . Isso identifica todos os elementos máximos, pois pode haver no máximo um elemento máximo por cadeia.$w$$P$$P$$O(w\log n)$

ADICIONADO: Na verdade, estou vendo um algoritmo recursivo simples para fazer muito melhor ( ) para a rede dos subconjuntos 2 [ n ] ( EDIT : domotor descreveu a estratégia geral em sua resposta). Aqui estou assumindo que P é monotônico para baixo (ou seja, os subconjuntos { X : P ( X ) = 1 } formam um conjunto inferior), que é o que você quer dizer. Então, aqui está o algoritmo para encontrar um membro do conjunto inferior:$O(n)$$2^{[n]}$$P$$\{X: P(X) = 1\}$

a) Teste . Se 0, então pare.$P(\emptyset)$

b) Teste . $P(\{n\})$

bi) Se 0, repita em (OK, pois nenhum conjunto contendo n pode estar no conjunto inferior).$2^{[n-1]}$$n$

b.ii) Se 1, existe um membro do conjunto inferior no sub-retículo . Esse sublatismo é isomórfico para 2 [ n - 1 ], para que mais uma vez possamos recuar. Mais precisamente, podemos executar o algoritmo para 2 [ n - 1 ] , mas quando o algoritmo pede para avaliar P ( Y ) , avaliamos P ( X ) onde X = Y ∪ { n } .$\{X: n \in X\}$$2^{[n-1]}$$2^{[n-1]}$$P(Y)$$P(X)$$X = Y \cup \{n\}$

Assim, em cada passo, recessamos em um sublático que é metade do tamanho do original. No geral, precisamos avaliar no máximo 2 n vezes (na verdade, você pode implementar o algoritmo para avaliar o predicado n + 1 vezes, como Yoshio aponta, já que você só precisa verificar ∅ uma vez).$P$$2n$$n+1$$\emptyset$

Se é uma árvore, existe um algoritmo de tempo polinomial que constrói uma árvore de decisão ideal.$P$

Generalização da pesquisa binária: pesquisa em árvores e ordens parciais semelhantes a florestas

Um artigo recente de Daskalakis et al. Mostra que, para um poset de tamanho e largura w , elementos mínimos podem ser encontrados no tempo O ( w n ) . O interessante é que, em seu resumo, eles dizem$n$$w$$O(wn)$

Também seria interessante encontrar estruturas de dados estáticas e dinâmicas eficientes que desempenham o mesmo papel para pedidos parciais que montes e árvores de pesquisa binária desempenham para pedidos totais.

Se S faz parte da entrada, o problema de encontrar um elemento máximo já se torna `` NP-hard '' (se pensarmos na estrutura de tal forma que seus elementos sejam n bits de cadeia longa), por exemplo, você pode dizer se CNF (x) não for verdadeiro e CNF (y) for verdadeiro para algum CNF fixo.$x<y$

Além disso, pode haver muitos elementos máximos que satisfazem P; portanto, mesmo a saída de todos eles pode demorar muito, então acho que há apenas esperança de encontrar um máximo.

Em geral, a pesquisa binária funciona se você puder selecionar recursivamente elementos de forma que, depois de ficar com os elementos acima, ou os elementos acima sejam excluídos, e em todos esses conjuntos uma proporção fixa dos elementos seja excluída.

Por exemplo. se S é uma grade dimensional fixa, existe um algoritmo rápido: sempre reduza pela metade uma coordenada enquanto mantém as outras mínimas; portanto, pergunte, por exemplo, na primeira etapa (n / 2,0, ..., 0).

$n^d$

$P$$2^{[n]}$$n$$P$$P$