Минимальный размер заключения DAG в новый DAG

У нас есть DAG. У нас есть функция на узлах (грубо говоря, мы нумеруем узлы). Мы хотели бы создать новый ориентированный граф с этими правилами:$F\colon V\to \mathbb N$

1. Только узлы с одинаковым номером могут быть заключены в один и тот же новый узел. . (Однако .)x ′ ≠ y ′ ⇏ F ( x ) ≠ F ( y $F(x) \neq F(y) \Rightarrow x' \neq y'$$x' \neq y'\nRightarrow F(x) \neq F(y)$
2. Мы добавляем все старые ребра между новыми узлами: $(x,y) \in E \land x' \neq y' \iff (x',y')\in E'$ .
3. Этот новый график все еще DAG.

Что такое минимальное $|V'|$? Что такое алгоритм создания минимального нового графа?

Одним из подходов к решению этой проблемы было бы использование целочисленного линейного программирования (ILP). Давайте рассмотрим вариант решения проблемы: учитывая , есть ли способ сжимать вершины одного цвета, чтобы получить DAG размера ?≤ $k$$\le k$

Это можно выразить как экземпляр ILP с использованием стандартных методов. Нам дан цвет каждой вершины в исходном графе. Я предлагаю пометить каждую вершину меткой в ; все вершины с одинаковой меткой и одинаковым цветом будут сокращены. Итак, решается проблема: существует ли маркировка, такая, что сжатие всех вершин одного цвета с одинаковой меткой дает DAG?$\{1,2,\dots,k\}$

Чтобы выразить это как целочисленную линейную программу, целочисленную переменную для каждой вершины , чтобы представить метку на вершине . Добавьте неравенство . v v 1 ≤ л v ≤ $\ell_v$$v$$v$$1 \le \ell_v \le k$

Следующим шагом является выражение требования, чтобы контрактный граф был DAG. Обратите внимание, что если есть маркировка формы, перечисленной выше, без потери общности существует такая маркировка, где метки индуцируют топологическую сортировку на сжатом графе (т. Е. Если предшествует в свернутом графе, то метка ' меньше, чем метка ). Таким образом, для каждого ребра в исходном графе мы добавим ограничение, что либо и имеют одинаковую метку и одинаковый цвет, либо метка меньше метки . Конкретно для каждого ребраw v w v → w v w v w v → w v , w ℓ v ≤ ℓ w v → w v , w ℓ v < ℓ $v$$w$$v$$w$$v\to w$$v$$w$$v$$w$$v\to w$в начальном графе, где имеют одинаковый цвет, добавьте неравенство . Для каждого ребра где имеют разные цвета, добавьте неравенство .$v,w$$\ell_v \le \ell_w$$v \to w$$v,w$$\ell_v < \ell_w$

Теперь посмотрим, есть ли возможное решение этой целочисленной линейной программы. Будет возможным решением, если и только если маркировка имеет желаемую форму (т. Е. Сокращение всех вершин одного цвета с одинаковой меткой дает DAG). Другими словами, будет выполнимое решение тогда и только тогда, когда есть способ свернуть исходный граф с DAG размера . Мы можем использовать любой решатель целочисленного линейного программирования; если решатель ILP дает нам ответ, у нас есть ответ на первоначальное решение проблемы.$\le k$

Конечно, это не гарантированно завершится за полиномиальное время. Там нет никаких гарантий. Тем не менее, ILP решатели получили довольно хорошо. Я ожидаю, что для графа разумного размера у вас есть хороший шанс, что решатель ILP сможет решить эту проблему за разумное время.

Также возможно закодировать это как экземпляр SAT и использовать решатель SAT. Я не знаю, будет ли это более эффективным. Версия ILP, вероятно, легче думать, хотя.

(Надеюсь, это правильно. Я не проверил каждую деталь тщательно, поэтому, пожалуйста, перепроверьте мои рассуждения! Надеюсь, я не ошибся.)

Обновление (10/21): Похоже, что ILP этой формы можно решить за линейное время, обрабатывая DAG в топологически отсортированном порядке и отслеживая нижнюю границу метки для каждой вершины. Это вызывает у меня подозрение по поводу моего решения: я где-то допустил ошибку?

ПРИМЕЧАНИЕ: AFAICT, DW нашел дыру в этом сокращении, и это неправильно (см. Комментарии). Хранение здесь по историческим причинам.

Введение : сначала я сведу проблему Monotone 3SAT к нашей проблеме. Хотя проблема Monotone 3SAT тривиально выполнима, наша проблема может дополнительно решить проблему Minimum True Monotone 3SAT , которая является NP-трудной; таким образом, эта проблема является NP-трудной.

Сокращение от Monotone 3SAT до нашей проблемы

У нас есть монотонная логическая формула, выраженная в виде последовательности переменных и последовательности предложений. CNF имеет вид такой, что:$\Phi = (\mathcal V,\mathcal C)$

и

преобразование

Построим граф, . Каждая вершина в G ' имеет метку; вершины с одинаковыми метками имеют право на сжатие.$G'=V',E'$$G'$

Сначала мы построим график следующим образом: для каждого мы создадим два узла, каждый из которых помечен x i , и направленный край от одного к другому (щелкните изображения для просмотра в высоком разрешении).$x_i \in \mathcal V$$x_i$

Эти узлы, конечно, могут быть сокращены, потому что они имеют одинаковую метку. Мы будем рассматривать переменные / узлы, которые по контракту, будут оценены как ложные, а те, которые не сокращены, будут оценены как истинные :

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

Вот еще одна визуализация, разворачивающая ограничение предложения:

Таким образом, каждое ограничение предложения требует, чтобы по крайней мере одна из переменных, которые в нем содержались, оставалась не сокращенной; поскольку несокращенные узлы оцениваются как истинные, для этого требуется, чтобы одна из переменных была истинной; именно то, что Monotone SAT требует для своих пунктов.

Сокращение от минимального истинного монотона 3SAT

Монотон 3SAT тривиально удовлетворителен; Вы можете просто установить все переменные в true.

Тем не менее, поскольку наша задача минимизации DAG состоит в том, чтобы найти наибольшее количество сокращений, это означает, что нужно найти удовлетворяющее назначение, которое дает большинство ложных переменных в нашем CNF; что аналогично нахождению минимальных истинных переменных. Эта проблема иногда называется Minimum True Monotone 3SAT или здесь (как проблема оптимизации или проблема решения), или k-True Monotone 2SAT (как проблема с более слабым решением); обе NP-сложные проблемы. Таким образом, наша проблема является NP-трудной.

Ссылки:

• Минимальный истинный монотон 3SAT
• Докажите NP-полноту определения выполнимости монотонной булевой формулы
• Monotone-2SAT и покрытие Vertex

График источников:

• источник на суть
• посмотреть на writelatex

С каждой заменой (за исключением прямых замен родитель-потомок) вы добавляете новые отношения предок-потомок, которые делают нетривиальным определение того, какой из них действительно стоит в долгосрочной перспективе. Следовательно, простой жадный алгоритм в общем случае потерпит неудачу. Однако, если вы используете метод грубой силы, вы можете определить наименьший график:

Python-ish (не проверено):

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)

Я не уверен, что это действительно сложная проблема, но играя с некоторыми графиками вручную, это кажется очень комбинаторным. Мне любопытно, если что-то сложное можно свести к этой проблеме, или есть алгоритм с лучшим временем выполнения.