Dimensione minima di contrarre un DAG in un nuovo DAG

Abbiamo un DAG. Abbiamo una funzione sui nodi $F\colon V\to \mathbb N$ (parlando liberamente, contiamo i nodi). Vorremmo creare un nuovo grafico diretto con queste regole:

1. Solo i nodi con lo stesso numero possono essere contratti nello stesso nuovo nodo. . (Tuttavia, .)$F(x) \neq F(y) \Rightarrow x' \neq y'$$x' \neq y'\nRightarrow F(x) \neq F(y)$
2. Aggiungiamo tutti i bordi vecchi tra i nuovi nodi: $(x,y) \in E \land x' \neq y' \iff (x',y')\in E'$ .
3. Questo nuovo grafico è ancora un DAG.

Qual è il minimo $|V'|$? Che cos'è un algoritmo che crea un nuovo grafico minimo?

Un approccio per risolvere questo problema sarebbe quello di utilizzare la programmazione lineare intera (ILP). Affrontiamo la versione decisionale del problema: dato , c'è un modo per contrarre vertici dello stesso colore per ottenere un DAG di dimensioni ≤ k ?$k$$\le k$

Questo può essere espresso come un'istanza ILP usando tecniche standard. Ci viene dato il colore di ciascun vertice nel grafico originale. Suggerisco di etichettare ogni vertice con un'etichetta in ; tutti i vertici con la stessa etichetta e lo stesso colore verranno contratti. Quindi, il problema decisionale diventa: esiste un'etichettatura, tale che contrarre tutti i vertici dello stesso colore dello stesso colore produce un DAG?$\{1,2,\dots,k\}$

Per esprimerlo come un programma lineare intero, introdurre una variabile intera per ciascun vertice v , per rappresentare l'etichetta sul vertice v . Aggiungi la disuguaglianza 1 ≤ ℓ v ≤ k .$\ell_v$$v$$v$$1 \le \ell_v \le k$

Il passaggio successivo consiste nell'esprimere il requisito secondo cui il grafico contrattato deve essere un DAG. Si noti che se esiste un'etichettatura del modulo sopra elencato, senza perdita di generalità esiste una tale etichettatura in cui le etichette inducono un ordinamento topologico sul grafico contratto (cioè, se precede w nel grafico contratto, quindi l'etichetta v è più piccolo dell'etichetta di w ). Quindi, per ogni bordo v → w nel grafico originale, aggiungeremo il vincolo che v e w abbiano la stessa etichetta e lo stesso colore, altrimenti l'etichetta v è più piccola dell'etichetta w . In particolare, per ciascun bordo $v$$w$$v$$w$$v\to w$$v$$w$$v$$w$ nel grafico iniziale in cui v , w ha lo stesso colore, aggiungere la disuguaglianza ℓ v ≤ ℓ w . Per ogni bordo v → w dove v , w hanno colori diversi, aggiungere la disuguaglianza ℓ v < ℓ w .$v\to w$$v,w$$\ell_v \le \ell_w$$v \to w$$v,w$$\ell_v < \ell_w$

Ora vedi se esiste una soluzione fattibile per questo programma lineare intero. Ci sarà una soluzione fattibile se e solo se l'etichettatura è nella forma desiderata (cioè, contrarre tutti i vertici dello stesso colore dello stesso colore produce un DAG). In altre parole, ci sarà una soluzione fattibile se e solo se c'è un modo per contrarre il grafico originale su un DAG di dimensioni . Possiamo usare qualsiasi risolutore di programmazione lineare intero; se il risolutore ILP ci dà una risposta, abbiamo una risposta al problema decisionale originale.$\le k$

Naturalmente, questo non è garantito per il completamento in tempo polinomiale. Non ci sono garanzie Tuttavia, i solutori di ILP sono diventati piuttosto buoni. Mi aspetto che, per un grafico di dimensioni ragionevoli, si abbia una buona possibilità che un risolutore di ILP sia in grado di risolvere questo problema in un ragionevole lasso di tempo.

È anche possibile codificarlo come istanza SAT e utilizzare un solutore SAT. Non so se sarebbe più efficace. La versione ILP è probabilmente più facile da pensare, però.

(Spero che sia giusto. Non ho controllato attentamente ogni dettaglio, quindi per favore ricontrolla il mio ragionamento! Spero di non essere andato storto da qualche parte.)

Aggiornamento (10/21): sembra che gli ILP di questo modulo possano essere risolti in tempo lineare, elaborando il DAG in ordine topologicamente ordinato e tenendo traccia del limite inferiore sull'etichetta per ciascun vertice. Questo mi fa sospettare della mia soluzione: ho fatto un errore da qualche parte?

NOTA: AFAICT, DW ha trovato un buco in questa riduzione ed è sbagliato (vedi commenti). Conservandolo qui per motivi storici.

Intro : prima ridurrò il problema Monotone 3SAT al nostro problema. Sebbene il problema Monotone 3SAT sia banalmente soddisfacente, il nostro problema può ulteriormente risolvere il problema minimo True Monotone 3SAT , che è NP-difficile; quindi questo problema è NP-difficile.

Riduzione da Monotone 3SAT al nostro problema

Abbiamo una formula booleana monotona espressa come una sequenza di variabili e una sequenza di clausole. Il CNF ha la forma tale che:$\Phi = (\mathcal V,\mathcal C)$

e

Conversione

Costruiamo un grafico, . Ogni vertice in G ' ha un'etichetta; i vertici con la stessa etichetta sono idonei alla contrazione.$G'=V',E'$$G'$

Innanzitutto costruiamo il grafico come segue: per ogni , creiamo due nodi, ciascuno etichettato x i , e un bordo diretto da uno all'altro (fare clic sulle immagini per una vista ad alta risoluzione).$x_i \in \mathcal V$$x_i$

Questi nodi possono ovviamente essere contratti, perché hanno la stessa etichetta. Considereremo variabili / nodi che vengono contrattati valutati come falsi e quelli che non sono contrattati vengono valutati come veri :

$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$

Ecco un'altra visualizzazione, srotolando il vincolo della clausola:

Pertanto, ogni vincolo di clausola richiede che almeno una delle variabili che contiene rimanga non contrattata; poiché i nodi non contratti sono valutati come veri, ciò richiede che una delle variabili sia vera; esattamente ciò che richiede Monotone SAT per le sue clausole.

Riduzione dal minimo True Monotone 3SAT

Monotone 3SAT è banalmente soddisfacente; puoi semplicemente impostare tutte le variabili su true.

Tuttavia, poiché il nostro problema di minimizzazione del DAG è trovare la maggior parte delle contrazioni, ciò si traduce nella ricerca dell'assegnazione soddisfacente che produce il maggior numero di variabili false nel nostro CNF; che equivale a trovare le variabili minime vere. Questo problema viene talvolta chiamato Minimo True 3SAT minimo o qui (come problema di ottimizzazione o problema decisionale) o k-True Monotone 2SAT (come problema di decisione più debole); entrambi i problemi NP-difficili. Quindi il nostro problema è NP-difficile.

Riferimenti:

• Minimo True Monotone 3SAT
• Dimostrare completezza NP nel decidere la soddisfacibilità della formula booleana monotona
• Copertura monotono-2SAT e vertice

Fonti del grafico:

• fonte su sostanza
• visualizza su writelatex

With each replacement (except for direct-parent-child replacements), you add new ancestor-descendant relationships that make it non-trivial to determine which one is actually worth it in the long-term. Therefore, a simple greedy algorithm will fail in the general case. However, if you do a brute-force approach, you can determine the smallest graph:

Python-ish (not tested):

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)

I am not sure if it really a hard problem, but playing with some graphs manually, it seems very combinatorial. I am curious if something difficult can be reduced to this problem, or if there is an algorithm with better running time.