DAG'ı yeni bir DAG'a almanın minimum boyutu

Bir DAG'ımız var. düğümlerinde bir fonksiyonumuz var $F\colon V\to \mathbb N$(gevşek konuşma, düğümleri numaralandırıyoruz). Bu kurallarla yeni bir yönlendirilmiş grafik oluşturmak istiyoruz:

1. $F(x) \neq F(y) \Rightarrow x' \neq y'$$x' \neq y'\nRightarrow F(x) \neq F(y)$
2. Tüm eski kenarları yeni düğümler arasına ekliyoruz: .$(x,y) \in E \land x' \neq y' \iff (x',y')\in E'$
3. Bu yeni grafik hala bir DAG.

Minimum nedir? Minimal yeni bir grafik oluşturan algoritma nedir?$|V'|$

Bu sorunun çözümünde bir yaklaşım, tamsayılı doğrusal programlama (ILP) kullanmak olacaktır. Sorunun karar versiyonunu ele alalım: verildiğinde , boyutunda bir DAG almak için aynı renk köşelerini daraltmanın bir yolu var mı?≤ $k$$\le k$

Bu, standart teknikler kullanılarak bir ILP örneği olarak ifade edilebilir. Orijinal grafikteki her bir tepe noktasının rengi verilir. Her tepe noktasını ; aynı etikete ve aynı renge sahip tüm köşeler daralacaktır. Böylece, karar sorunu şöyle olur: Aynı renkteki aynı etiket köşelerinin daraltılması bir DAG verecek şekilde bir etiketleme var mı?$\{1,2,\dots,k\}$

Bunu bir tamsayı doğrusal program olarak ifade etmek için , tepe noktasında etiketi temsil etmek üzere her köşe için tamsayı değişkenini . Eşitsizliği . v v 1 ≤ ℓ v ≤ $\ell_v$$v$$v$$1 \le \ell_v \le k$

Bir sonraki adım, sözleşmeli grafiğin bir DAG olması gerektiğini ifade etmektir. Uyarı etiketlerin taahhütlü grafik üzerinde topolojik tür (indükleyen bir etiketleme vardır genelliği kaybetmeden, yukarıda listelenen biçimde bir etiketleme, var ise, yani, eğer ilerlettiği taahhütlü grafikte, sonra 'etiketinde etiketinden daha küçüktür ). Bu nedenle, orijinal grafikteki her kenarı için , ve aynı etikete ve aynı renge sahip olduğu ya da etiketinin etiketinden küçük olduğu kısıtlamasını ekleyeceğiz . Özellikle, her kenar için$v$$w$$v$$w$$v\to w$$v$$w$$v$$w$$v\to w$ aynı renge sahip olduğu ilk grafikte eşitsizliği . Her kenar için burada farklı renklere sahiptir, eşitsizliği ekleyin .$v,w$$\ell_v \le \ell_w$$v \to w$$v,w$$\ell_v < \ell_w$

Şimdi bu tamsayı doğrusal programın uygulanabilir bir çözümü olup olmadığına bakın. Sadece etiketleme istenen formda ise (yani, aynı renkteki aynı etiket köşe noktalarının daraltılması bir DAG sağlıyorsa) uygulanabilir bir çözüm olacaktır. Başka bir deyişle, yalnızca orijinal grafiği boyutunda bir DAG ile daraltmanın bir yolu varsa ve uygun bir çözüm olacaktır . Herhangi bir tamsayılı doğrusal programlama çözücüsünü kullanabiliriz; ILP çözücüsü bize bir cevap verirse, orijinal karar sorununa bir cevabımız var.$\le k$

Elbette, bunun polinom zamanında tamamlanması garanti edilmez. Hiçbir garanti yok. Ancak, ILP çözücüleri oldukça iyi oldu. Makul boyutlu bir grafik için, bir ILP çözücüsünün bu sorunu makul bir süre içinde çözebilmesi için iyi bir şansınız olmasını beklerim.

Bunu bir SAT örneği olarak kodlamak ve bir SAT çözücü kullanmak da mümkündür. Bunun daha etkili olup olmayacağını bilmiyorum. Yine de ILP versiyonunu düşünmek daha kolaydır.

(Umarım bu doğrudur. Her ayrıntıyı dikkatlice kontrol etmedim, bu yüzden lütfen akıl yürütümü tekrar kontrol edin!

Güncelleme (10/21): Bu formun ILP'leri, DAG'ı topolojik olarak sıralanmış bir sırayla işleyerek ve her bir tepe noktası için etiketin alt sınırını takip ederek doğrusal zamanda çözülebiliyor gibi görünüyor. Bu benim çözümümden şüpheleniyor: bir yerde hata mı yaptım?

NOT: AFAICT, DW bu azaltmada bir delik buldu ve yanlış (yorumlara bakın). Tarihi nedenlerle burada tutmak.

Giriş : Önce Monotone 3SAT problemini sorunumuza indireceğim . Monoton 3SAT sorunu önemsiz olarak tatmin edilebilir olsa da , sorunumuz NP-zor olan Minimum True Monotone 3SAT problemini daha da çözebilir ; dolayısıyla bu problem NP zordur.

Monoton 3SAT'den sorunumuza azalma

Değişkenler dizisi ve cümle dizisi olarak ifade edilen monoton bir boolean formülümüz var. CNF, formundadır , öyle ki:$\Phi = (\mathcal V,\mathcal C)$

ve

Dönüştürmek

Bir grafik yapıyoruz, . G ' deki her tepe noktasının bir etiketi vardır; aynı etikete sahip köşeler büzülmeye uygundur.$G'=V',E'$$G'$

İlk önce grafiği aşağıdaki gibi yapılandırıyoruz: her için, her biri x i etiketli iki düğüm ve birinden diğerine yönlendirilmiş bir kenar yapıyoruz (yüksek çözünürlüklü görünüm için resimlere tıklayın).$x_i \in \mathcal V$$x_i$

Bu düğümler elbette büzülebilir, çünkü aynı etikete sahiptirler. Kıymetli olarak değerlendirilen değişken / düğümleri yanlış, kıymetsiz olanları ise doğru olarak değerlendireceğiz :

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

İşte yan tümce kısıtlamasını açığa çıkaran başka bir görselleştirme:

Bu nedenle, her bir madde kısıtı içerdiği değişkenlerden en az birinin yüklenmemiş kalmasını gerektirir; büzülmemiş düğümler doğru olarak değerlendiğinden, bu değişkenlerden birinin doğru olmasını gerektirir; Monotone SAT'ın cümleleri için tam olarak gerekeni.

Minimum Gerçek Monoton 3SAT'den Azaltma

Monoton 3SAT önemsiz bir şekilde tatmin edilebilir; tüm değişkenleri true olarak ayarlayabilirsiniz.

Ancak, DAG minimizasyon problemimiz en fazla kasılmayı bulmak olduğundan, bu CNF'mizde en yanlış değişkenleri üreten tatmin edici ödevi bulmak anlamına gelir; minimum gerçek değişkenleri bulmakla aynıdır. Bu soruna bazen Minimum True Monotone 3SAT veya burada (bir optimizasyon sorunu veya karar sorunu olarak) veya k-True Monotone 2SAT (daha zayıf bir karar sorunu olarak) denir ; her iki NP zor problem. Bu yüzden sorunumuz NP zor.

Referanslar:

• Minimum Gerçek Monoton 3SAT
• Monoton boolean formülünün tatmin edilebilirliğine karar vermenin NP tamlığını kanıtlayın
• Monoton-2SAT ve Tepe Kapağı

Grafik kaynakları:

• özünde kaynak
• writelatex üzerinde görüntüle

Her değiştirme işleminde (doğrudan ebeveyn-çocuk değiştirmeleri hariç), uzun vadede hangisinin buna değdiğini belirlemeyi önemsiz hale getiren yeni ata-torun ilişkileri eklersiniz. Bu nedenle, basit bir açgözlü algoritma genel durumda başarısız olacaktır. Ancak, kaba kuvvet yaklaşımı yaparsanız, en küçük grafiği belirleyebilirsiniz:

Python-ish (test edilmedi):

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)

Gerçekten zor bir sorun olup olmadığından emin değilim, ancak bazı grafikler ile manuel olarak oynamak, çok birleştirici görünüyor. Zor bir şeyin bu probleme indirgenebileceğini veya daha iyi çalışma süresine sahip bir algoritma olup olmadığını merak ediyorum.