Tamanho mínimo de contratação de um DAG em um novo DAG

Nós temos um DAG. Temos uma função nos nós (falando livremente, numeramos os nós). Gostaríamos de criar um novo gráfico direcionado com estas regras:$F\colon V\to \mathbb N$

1. Somente nós com o mesmo número podem ser contratados no mesmo novo nó. . (No entanto, .)$F(x) \neq F(y) \Rightarrow x' \neq y'$$x' \neq y'\nRightarrow F(x) \neq F(y)$
2. Adicionamos todas as arestas antigas entre os novos nós: $(x,y) \in E \land x' \neq y' \iff (x',y')\in E'$ .
3. Este novo gráfico ainda é um DAG.

Qual é o mínimo $|V'|$? O que é um algoritmo que cria um novo gráfico mínimo?

Uma abordagem para resolver esse problema seria usar a programação linear inteira (ILP). Vamos abordar a versão de decisão do problema: dado , existe uma maneira de contratar vértices da mesma cor para obter um DAG de tamanho ≤ k ?$k$$\le k$

Isso pode ser expresso como uma instância de ILP usando técnicas padrão. Recebemos a cor de cada vértice no gráfico original. Sugiro que rotulemos cada vértice com um rótulo em ; todos os vértices com a mesma etiqueta e a mesma cor serão contratados. Portanto, o problema de decisão se torna: existe uma rotulagem, de modo que a contratação de todos os vértices da mesma cor da mesma etiqueta produza um DAG?$\{1,2,\dots,k\}$

Para expressar isso como um programa linear inteiro, introduza uma variável inteira para cada vértice v , para representar o rótulo no vértice v . Adicione a desigualdade 1 ≤ ℓ v ≤ k .$\ell_v$$v$$v$$1 \le \ell_v \le k$

A próxima etapa é expressar o requisito de que o gráfico contratado deve ser um DAG. Observe que, se houver uma rotulagem do formulário listado acima, sem perda de generalidade, existe uma rotulagem em que os rótulos induzem uma classificação topológica no gráfico contratado (ou seja, se precede w no gráfico contratado, o rótulo de v é menor que o rótulo de w ). Portanto, para cada aresta v → w no gráfico original, adicionaremos a restrição de que v e w têm a mesma etiqueta e a mesma cor, ou então o rótulo de v é menor que o rótulo de w . Especificamente, para cada aresta $v$$w$$v$$w$$v\to w$$v$$w$$v$$w$ no gráfico inicial em que v , w tem a mesma cor, adicione a desigualdade ℓ v ≤ ℓ w . Para cada aresta v → w onde v , w tem cores diferentes, adicione a desigualdade ℓ v < ℓ w .$v\to w$$v,w$$\ell_v \le \ell_w$$v \to w$$v,w$$\ell_v < \ell_w$

Agora veja se existe alguma solução viável para esse programa linear inteiro. Haverá uma solução viável se, e somente se, a etiqueta tiver a forma desejada (por exemplo, a contratação de todos os vértices da mesma etiqueta da mesma cor produz um DAG). Em outras palavras, haverá uma solução viável se, e somente se, houver uma maneira de contratar o gráfico original para um DAG de tamanho . Podemos usar qualquer solucionador de programação linear inteiro; se o solucionador de ILP nos der uma resposta, temos uma resposta para o problema de decisão original.$\le k$

Obviamente, isso não garante que seja concluído em tempo polinomial. Não há garantias. No entanto, os solucionadores de ILP ficaram muito bons. Eu esperaria que, para um gráfico de tamanho razoável, você tenha uma chance decente de que um solucionador de ILP possa resolver esse problema em um período de tempo razoável.

Também é possível codificar isso como uma instância SAT e usar um solucionador SAT. Não sei se isso seria mais eficaz. A versão do ILP é provavelmente mais fácil de se pensar.

(Espero que esteja certo. Não verifiquei todos os detalhes com cuidado; portanto, verifique novamente meu raciocínio! Espero não ter dado errado em algum lugar.)

Atualização (21/10): Parece que os ILPs deste formulário podem ser resolvidos em tempo linear, processando o DAG em ordem topológica e mantendo o controle do limite inferior no rótulo de cada vértice. Isso me desconfia da minha solução: cometi um erro em algum lugar?

NOTA: AFAICT, DW encontrou um buraco nessa redução e está errado (consulte os comentários). Mantê-lo aqui por razões históricas.

Introdução : primeiro vou reduzir o problema do Monotone 3SAT ao nosso problema. Embora o problema do Monotone 3SAT seja trivialmente satisfatório, nosso problema pode resolver ainda mais o problema do Mínimo Verdadeiro Monotone 3SAT , que é difícil para NP; portanto, esse problema é difícil de NP.

Redução do Monotone 3SAT para o nosso problema

Temos uma fórmula booleana monótona expressa como uma sequência de variáveis ​​e uma sequência de cláusulas. O CNF tem a forma tal que:$\Phi = (\mathcal V,\mathcal C)$

e

Conversão

Construímos um gráfico, . Cada vértice em G ' tem um rótulo; vértices com o mesmo rótulo são elegíveis para contração.$G'=V',E'$$G'$

Primeiro, construímos o gráfico da seguinte maneira: para cada , criamos dois nós, cada um rotulado x i , e uma aresta direcionada de um para o outro (clique nas imagens para visualizar em alta resolução).$x_i \in \mathcal V$$x_i$

É claro que esses nós podem ser contratados porque têm o mesmo rótulo. Consideraremos variáveis ​​/ nós contratados como valor falso e aqueles que não forem contratados como valor verdadeiro :

$V'$$2\cdot \left|\mathcal V\right|$$c_i \in \mathcal C, ~ \left.c_i = (x_j \vee x_k \vee x_l) \right|_{x_j,x_k,x_l \in \mathcal V}$$c_i$

^{$c_i$$1$$c_i$}

$2\cdot \left|\mathcal V\right| + |\mathcal C|$

$x_i$$x_j$ $x_k$$c_i \rightarrow c_i$

Aqui está outra visualização, desenrolando a restrição de cláusula:

Assim, cada restrição de cláusula requer que pelo menos uma das variáveis ​​que ela contenha permaneça não contratada; como os nós não contratados são avaliados como verdadeiros, isso requer que uma das variáveis ​​seja verdadeira; exatamente o que o Monotone SAT exige para suas cláusulas.

Redução do Mínimo Verdadeiro Monótono 3SAT

O monótono 3SAT é trivialmente satisfatório; você pode simplesmente definir todas as variáveis ​​como true.

No entanto, como nosso problema de minimização do DAG é encontrar o maior número de contrações, isso significa encontrar a atribuição satisfatória que produz as variáveis ​​mais falsas em nossa CNF; que é o mesmo que encontrar as variáveis ​​verdadeiras mínimas. Às vezes, esse problema é chamado Minimum True Monotone 3SAT ou aqui (como um problema de otimização ou problema de decisão) ou k-True Monotone 2SAT (como um problema de decisão mais fraco); problemas NP-difíceis. Assim, o nosso problema é difícil para o NP.

Referências:

• Mínimo Verdadeiro Monótono 3SAT
• Prove que a NP está completa para decidir a satisfação da fórmula booleana monótona
• Tampa Monotone-2SAT e Vertex

Fontes do gráfico:

• fonte na essência
• ver em writelatex

A cada substituição (exceto as substituições pai-filho diretas), você adiciona novos relacionamentos de ancestrais-descendentes que tornam pouco trivial determinar qual deles realmente vale a pena a longo prazo. Portanto, um algoritmo ganancioso simples falhará no caso geral. No entanto, se você fizer uma abordagem de força bruta, poderá determinar o menor gráfico:

Python-ish (não testado):

def play((V,E),F,sequence=[]):
  """
  (V,E) -- a dag.
  V     -- a set of vertices.
  E     -- a set of directed-edge-tuples.
  F     -- a function that takes a vertex, returns an integer.
  sequence -- the sequence of moved taken so far; starts with/defaults to
              an empty list, will contain tuples of the form (x,y)
              where x is removed and replaced with y.

  Returns the best recursively found solution.
  """

  #find all the integer values in the graph, remember which
  # values correspond to what vertices. Of the form {integer => {vertices}}.
  n2v = {}
  for x in V:
    n = F(x)

    #for each integer, make sure you have a set to put the vertices in.
    if n not in n2v:
      n2v[n] = set()

    #for each integer, add the vertex to the equivalent set.
    n2v[n].add(v)

  #record the best sequence/solution. You start with the current sequence,
  # and see if you can obtain anything better.
  best_solution = list(sequence)

  #Now you will try to combine a single pair of vertices, obtain a new
  # graph and then recursively play the game again from that graph. 

  #for each integer and equivalent set of vertices,
  for n,vset in n2v.iteritems():

    #pick a pair of vertices
    for x in vset:
      for y in vset:

        #no point if they are the same.
        if x == y:
          continue

        #If there is a path from x => y or y => x, then you will be
        # introducing a cycle, breaking a rule. So in that case, disregard
        # this pair.
        #However, the exception is when one is a direct child of the other;
        # in that case you can safely combine the vertices.
        if pathtest((V,E),x,y) and (x,y) not in E and (x,y) not in E:
          continue

        #combine the vertices (function is defined below), discard x,
        # replace it with y, obtain the new graph, (V',E').
        Vp,Ep = combine_vertex((V,E),x,y))

        #record the sequence for this move.
        sequencep = list(sequence) + [(x,y)]

        #recurse and play the game from this new graph.
        solution = play(Vp,Ep,F,sequencep)

        #if the returned solution is better than the current best,
        if len(solution) > len(best_solution):
          #record the new best solution
          best_solution = solution
  #return the best recorded solution
  return best_solution


def combine_vertex((V0,E0),x,y):
  """
  (V0,E0)   -- an initial digraph.
  V0        -- a set of vertices.
  E0        -- a set of directed-edge-tuples.
  x         -- vertex to discard.
  y         -- vertex to replace it with.

  returns a new digraph replacing all relationships to and from x to relate
   to y instead, and removing x from the graph entirely.
  """

  #the final vertex set will have everything except x
  V = set(V0)
  V.discard(x)

  #now you construct the edge set.
  E = set()

  #for every edge,
  for (u0,v0) in E0:
    #recreate the edge in the new graph, but replace any occurence
    # of x.  
    u,v = u0,v0
    #if x is in the edge: replace it
    if u == x:
      u = y
    if v == x:
      v == y

    #sometimes u=v=y and can now be pointing to itself, don't add that
    # edge
    if u == v:
      continue

    #add the new/replaced edge into the edge-set.
    E.add( (u,v) )
  return (V,E)

Não tenho certeza se é realmente um problema difícil, mas brincar com alguns gráficos manualmente parece muito combinatório. Estou curioso para saber se algo difícil pode ser reduzido a esse problema ou se existe um algoritmo com melhor tempo de execução.