एक डीएजी को नए डीएजी में अनुबंधित करने का न्यूनतम आकार

Question

हमारे पास एक डीएजी है। हमारे पास नोड्स पर एक फ़ंक्शन है $F\colon V\to \mathbb N$ (शिथिल बोलना, हम नोड्स को संख्या देते हैं)। हम इन नियमों के साथ एक नया निर्देशित ग्राफ बनाना चाहेंगे:

1. $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. यह नया ग्राफ अभी भी एक डीएजी है।

न्यूनतम क्या है? एक न्यूनतम नया ग्राफ बनाने वाला एल्गोरिदम क्या है?$|V'|$

Comments

तो निर्णय की समस्या प्रतीत होती है: एक शीर्ष रंग का डीएजी और एक पूर्णांक , यह तय करें कि क्या एक ही रंग के साथ शीर्षों को अनुबंधित करके अधिकांश k शीर्षकों पर DAG है या नहीं । $k$$k$

— आंद्र सलाम

यदि आप दो जुड़े हुए नोड्स को अनुबंधित करते हैं, तो क्या आपको निषिद्ध स्व-पाश मिलता है?

— युवल फिल्मस

नहीं। 2. फिर से पढ़ें: हम केवल किनारे जोड़ते हैं यदि संकुचन के बाद दो नोड्स अभी भी अलग हैं। यदि दो नोड्स एक में सिकुड़ जाते हैं, तो हम किनारे को नहीं जोड़ते हैं।

— chx

@chx क्या आप "न्यूनतम" या "न्यूनतम" पूछ रहे हैं?

— Realz Slaw

क्या आप कुछ प्रेरणा / bkg दे सकते हैं?

— vzn

Answer 1

इस समस्या को हल करने के लिए एक दृष्टिकोण पूर्णांक रैखिक प्रोग्रामिंग (ILP) का उपयोग करना होगा। चलो समस्या के निर्णय संस्करण से निपटने: दिए गए , वहाँ अनुबंध में एक ही रंग कोने के लिए एक रास्ता आकार का एक DAG पाने के लिए है ≤ कश्मीर ?$k$$\le k$

इसे मानक तकनीकों का उपयोग करके ILP उदाहरण के रूप में व्यक्त किया जा सकता है। हमें मूल ग्राफ में प्रत्येक शीर्ष का रंग दिया गया है। मेरा सुझाव है कि हम प्रत्येक शीर्ष को लेबल के साथ लेबल करते हैं ; एक ही लेबल और एक ही रंग के साथ सभी कोने अनुबंधित होंगे। तो, निर्णय की समस्या बन जाती है: क्या कोई लेबलिंग मौजूद है, जैसे कि सभी समान-रंग वाले समान-लेबल वर्टीकल्स को अनुबंधित करने से DAG उत्पन्न होता है?$\{1,2,\dots,k\}$

एक पूर्णांक रैखिक कार्यक्रम के रूप में व्यक्त करने के लिए, एक पूर्णांक चर परिचय प्रत्येक शिखर के लिए वी , शिखर पर लेबल का प्रतिनिधित्व करने के वी । असमानता जोड़े 1 ≤ ℓ वी ≤ कश्मीर ।$\ell_v$$v$$v$$1 \le \ell_v \le k$

अगला कदम यह आवश्यकता व्यक्त करना है कि अनुबंधित ग्राफ डीएजी होना चाहिए। सूचना है कि अगर ऊपर सूचीबद्ध प्रपत्र की एक लेबलिंग, व्यापकता की हानि के बिना इस तरह के एक लेबलिंग जहां लेबल अनुबंधित ग्राफ पर एक सांस्थितिकीय प्रकार (प्रेरित वहां मौजूद है यानी, अगर पछाड़ डब्ल्यू अनुबंधित ग्राफ में, फिर वी के लेबल डब्ल्यू के लेबल से छोटा है )। इसलिए, मूल ग्राफ में प्रत्येक किनारे v → w के लिए, हम बाधा को जोड़ देंगे कि v और w में एक ही लेबल और एक ही रंग है, या फिर v का लेबल w के लेबल से छोटा है । विशेष रूप से, प्रत्येक किनारे के लिए $v$$w$$v$$w$$v\to w$$v$$w$$v$$w$ प्रारंभिक ग्राफ में जहां वी , डब्ल्यू एक ही रंग है, असमानता जोड़ने ℓ वी ≤ ℓ डब्ल्यू । प्रत्येक बढ़त के लिए वी → डब्ल्यू जहां वी , डब्ल्यू अलग अलग रंग है, असमानता जोड़ने ℓ v < ℓ डब्ल्यू ।$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 उदाहरण के रूप में सांकेतिक शब्दों में बदलना और एक सैट सॉल्वर का उपयोग करने के लिए संभव है। मुझे नहीं पता कि यह अधिक प्रभावी होगा या नहीं। आईएलपी संस्करण के बारे में सोचना आसान है, हालांकि।

(मुझे आशा है कि यह सही है। मैंने हर विवरण को ध्यान से नहीं देखा है, इसलिए कृपया मेरे तर्क की दोबारा जाँच करें! मुझे आशा है कि मैं कहीं नहीं जागा।)

---

अद्यतन (10/21): ऐसा लगता है कि इस फॉर्म के ILP को रेखीय समय में हल किया जा सकता है, DAG को स्थैतिक रूप से क्रमबद्ध क्रम में संसाधित करके और प्रत्येक शीर्ष के लिए लेबल पर निचले बाउंड का ट्रैक रखते हुए। इससे मुझे अपने समाधान पर संदेह हुआ: क्या मैंने कहीं गलती की है?

Comments

विस्तृत उत्तर के लिए धन्यवाद! मुझे प्रतिबंध मिलते हैं और वे उचित लगते हैं। हालाँकि, जब मैं आईएलपी में अच्छी तरह से वाकिफ नहीं हूं, तो मुझे लगा कि पूर्णांक रैखिक प्रोग्रामिंग की आवश्यकता है एक फ़ंक्शन जिसे आप अधिकतम करना चाहते थे (या कम से कम) और मुझे वह कहीं भी दिखाई नहीं देता है। मैंने केवल विकिपीडिया में प्रतिवाद किया ताकि मैं गलत हो सकूँ।

— chx

@chx, मैं बाधाओं की व्यवहार्यता का परीक्षण करने के लिए ILP का उपयोग कर रहा हूं। यह ILP सॉल्वर को आपके द्वारा पसंद किए गए किसी भी उद्देश्य फ़ंक्शन (जैसे, अधिकतम 0) को अधिकतम करने के लिए कहकर किया जा सकता है, और फिर उद्देश्य फ़ंक्शन के मूल्य को अनदेखा कर सकता है और केवल यह देखने के लिए कि क्या ILP संभव है या नहीं। या तो आईएलपी solver प्रतिक्रिया "अव्यवहार्य" (जो कोई अनुबंधित है आकार की DAG का मतलब या यह प्रतिक्रिया करता है "व्यावहारिक" और उद्देश्य समारोह मिल सकता का सबसे अच्छा मूल्य प्रदान करता है); उस मामले में आप उद्देश्य फंक्शन का मान उपेक्षा (और आप जानते हैं कि वहाँ आकार का एक DAG मौजूद है ≤ कश्मीर )। $\le k$$\le k$

— डीडब्ल्यू

देखें, उदाहरण के लिए, Engineering.purdue.edu/~engelb/abe565/… ("मैं सिर्फ यह जानना चाहता हूं कि क्या कोई संभव समाधान मौजूद है या नहीं ।")

— DW

अपने रैखिक समय समाधान के बारे में; मैंने आपके ILP फॉर्मूलेशन को पचा नहीं लिया है, इसलिए मैं इसे जज नहीं कर सकता, लेकिन मुझे पूरा यकीन है कि मैं साबित कर सकता हूं कि समस्या एनपी-हार्ड है, जो एक रैखिक समय समाधान को काफी आसान बना देगा: पी। मैं इसे जल्द ही पोस्ट करने वाला हूं।

— Realz Slaw

@RealzSlaw, धन्यवाद! उस मामले में, मुझे दृढ़ता से संदेह है कि मैं कहीं भी मिटा सकता हूं (हालांकि मुझे यकीन नहीं है कि अभी तक कहां है)।

— DW

Answer 2

नोट: AFAICT, DW को इस कमी में एक छेद मिला और यह गलत है (टिप्पणियां देखें)। ऐतिहासिक कारणों से यहां रख रहे हैं।

परिचय : पहले मैं अपनी समस्या के लिए मोनोटोन 3SAT समस्या को कम करूंगा । हालांकि मोनोटोन 3SAT समस्या तुच्छ रूप से संतोषजनक है, हमारी समस्या न्यूनतम सच मोनोटोन 3SAT समस्या को हल कर सकती है, जो एनपी-हार्ड है; इस प्रकार यह समस्या एनपी-हार्ड है।

हमारी समस्या के लिए मोनोटोन 3SAT से कमी

हमारे पास एक मोनोटोन बूलियन सूत्र है जिसे चर के अनुक्रम के रूप में व्यक्त किया जाता है, और खंड का एक क्रम। CNF फॉर्म जैसे कि:$\Phi = (\mathcal V,\mathcal C)$

और

$$\forall_{\left(c_i \in \mathcal C\right)} ~ \left.c_i=\left(x_j \vee x_k \vee x_l\right) \vphantom{\LARGE | } \right|_{\left(x_j,x_k,x_l \in \mathcal V\right)}$$

$$\left.{\Large{\bigwedge}}_{i=1}^{n}{c_i}\right|_{\genfrac{}{}{0}{}{c_i\in \mathcal C,}{n=\left|\mathcal C\right|}}.$$

रूपांतरण

हम एक ग्राफ, निर्माण । जी ′ में प्रत्येक शीर्ष पर एक लेबल है; एक ही लेबल के साथ कोने संकुचन के लिए पात्र हैं।$G'=V',E'$$G'$

पहले हम ग्राफ के रूप में इस का निर्माण: प्रत्येक के लिए , हम दो नोड्स बनाने, प्रत्येक लेबल एक्स मैं , और अन्य के लिए एक से एक निर्देशित बढ़त (उच्च संकल्प दृश्य के लिए छवियों पर क्लिक करें)।$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$

यहाँ एक और दृश्य है, जो खंड अवरोध को नियंत्रित करता है:

इस प्रकार, प्रत्येक खंड बाधा के लिए आवश्यक है कि कम से कम एक चर जिसमें यह अनियंत्रित रहता है; चूंकि अनियंत्रित नोड्स को सही माना जाता है, इसके लिए यह आवश्यक है कि चर में से एक सत्य हो; इसके खंड के लिए वास्तव में मोनोटोन सैट को क्या चाहिए।

न्यूनतम सच मोनोटोन 3SAT से कटौती

मोनोटोन 3SAT तुच्छ रूप से संतोषजनक है; आप बस सभी चर को सही पर सेट कर सकते हैं।

हालाँकि, चूंकि हमारी डीएजी कम से कम समस्या सबसे अधिक संकुचन का पता लगाने के लिए है, यह हमारे सीएनएफ में सबसे गलत चर पैदा करने वाले संतोषजनक काम को खोजने के लिए अनुवाद करता है; जो न्यूनतम वास्तविक चर खोजने के समान है। इस समस्या को कभी-कभी मिनिमम ट्रू मोनोटोन 3SAT या यहाँ (एक अनुकूलन समस्या, या निर्णय समस्या के रूप में) या के-ट्रू मोनोटोन 2SAT (एक कमजोर निर्णय समस्या के रूप में) कहा जाता है; दोनों एनपी-कठिन समस्याएं। इस प्रकार हमारी समस्या एनपी-हार्ड है।

---

संदर्भ:

• न्यूनतम सच मोनोटोन 3SAT
• एनपी-पूर्णता को मोनोटोन बूलियन फार्मूले की संतोषजनकता तय करने के लिए साबित करें
• मोनोटोन -2 एसएटी और वर्टेक्स कवर

ग्राफ़ स्रोत:

• स्रोत जिस्ट पर
• रिटेलटेक्स पर देखें

Comments

वाह। तब डीडब्ल्यू का समाधान गलत होना चाहिए (या हमने एनपी = पी साबित किया है, जिस पर मुझे कुछ संदेह है: पी) - लेकिन कहां?

— chx

$(x_1 \lor x_2 \lor x_6) \land (x_1 \lor x_4 \lor x_5) \land (x_3 \lor x_4 \lor x_6)$$x_1=x_4=x_6=\text{False}$ $x_2=x_3=x_5=\text{True}$$c_1 \to x_1 \to x_4 \to x_6 \to c_1$

@DW भी आपसे बात करने के लिए अच्छा है: डी, ​​और सौभाग्य, अगर हम दोनों सही हैं तो हम आपके जवाब में P = NP हो सकते हैं! / jk

— Realz Slaw

$\left(x_1, x_3\right)$

@RealzSlaw, मुझे डर है कि मैं अभी तक का पालन नहीं करता ... मुझे कोई कारण नहीं दिखता कि मेरे सूत्र को क्यों बदलना पड़ेगा। मेरा मानना ​​है कि यह पहले से ही मिनिमम ट्रू मोनोटोन 3SAT का एक उदाहरण है। लेकिन मुझे इसे एक स्तर पर ले जाने दो। अधिक मोटे तौर पर, मुझे एक प्रस्तावित कमी दिखाई देती है, लेकिन मुझे कोई तर्क दिखाई नहीं देता कि कमी सही है - वह गायब है। कमी सही होने के लिए, यह हाँ उदाहरणों के लिए हाँ उदाहरणों के लिए है, और कोई उदाहरण नहीं, उदाहरणों के लिए। मुझे संदेह है कि यदि आप अपनी कमी के लिए शुद्धता का प्रमाण लिखने का प्रयास करते हैं, तो आप एक समस्या में भाग लेंगे जब आप मेरे द्वारा दिए गए फॉर्मूले पर विचार करेंगे।

— DW

Answer 3

प्रत्येक प्रतिस्थापन (प्रत्यक्ष-माता-पिता-बच्चे के प्रतिस्थापन को छोड़कर) के साथ, आप नए पूर्वजों-वंशज रिश्तों को जोड़ते हैं जो यह निर्धारित करने के लिए गैर-तुच्छ बनाते हैं कि कौन सा वास्तव में दीर्घकालिक में इसके लायक है। इसलिए, एक साधारण लालची एल्गोरिथ्म सामान्य मामले में विफल हो जाएगा। हालांकि, यदि आप एक जानवर-बल दृष्टिकोण करते हैं, तो आप सबसे छोटे ग्राफ को निर्धारित कर सकते हैं:

पायथन-ईश (परीक्षण नहीं):

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)

मुझे यकीन नहीं है कि यह वास्तव में एक कठिन समस्या है, लेकिन कुछ ग्राफ़ के साथ मैन्युअल रूप से खेलना, यह बहुत ही कम्बिनटेरियल लगता है। मुझे उत्सुकता है कि क्या इस समस्या को कुछ मुश्किल से कम किया जा सकता है, या यदि बेहतर चल रहे समय के साथ एक एल्गोरिथ्म है।

Comments

मैं बहुत उत्सुक हूँ :)

— chx