सामान्यीकृत वितरण नियम: Difference between revisions

From Vigyanwiki
 
(11 intermediate revisions by 3 users not shown)
Line 1: Line 1:
सामान्यीकृत वितरण कानून (जीडीएल) वितरण संपत्ति का एक सामान्यीकरण है जो एक सामान्य [[संदेश देना]] एल्गोरिदम को जन्म देता है।<ref name=GenDistLaw>{{cite journal|last=Aji|first=S.M.|author2=McEliece, R.J.|title=सामान्यीकृत वितरणात्मक कानून|journal=IEEE Transactions on Information Theory|date=Mar 2000|volume=46|issue=2|pages=325–343|doi=10.1109/18.825794|url=https://authors.library.caltech.edu/1541/1/AJIieeetit00.pdf}}</ref> यह [[सूचना सिद्धांत]], [[डिजिटल संचार]], [[ संकेत आगे बढ़ाना ]], सांख्यिकी और कृत्रिम बुद्धिमत्ता समुदायों में कई लेखकों के काम का संश्लेषण है। कानून और एल्गोरिदम को इसी शीर्षक के साथ श्रीनिवास एम. अजी और रॉबर्ट मैकएलीस|रॉबर्ट जे. मैकएलीस द्वारा एक अर्ध-ट्यूटोरियल में पेश किया गया था।<ref name=GenDistLaw />
'''सामान्यीकृत वितरण नियम''' (जीडीएल) वितरण गुण का एक ऐसा सामान्यीकरण है जो सामान्य [[संदेश देना]] एल्गोरिदम को जन्म देता है।<ref name=GenDistLaw>{{cite journal|last=Aji|first=S.M.|author2=McEliece, R.J.|title=सामान्यीकृत वितरणात्मक कानून|journal=IEEE Transactions on Information Theory|date=Mar 2000|volume=46|issue=2|pages=325–343|doi=10.1109/18.825794|url=https://authors.library.caltech.edu/1541/1/AJIieeetit00.pdf}}</ref> यह [[सूचना सिद्धांत]], डिजिटल संचार, [[ संकेत आगे बढ़ाना |संकेत आगे बढ़ाना]], सांख्यिकी और कृत्रिम बुद्धिमत्ता समुदायों में कई लेखकों के फलन का संश्लेषण है। अतः नियम और एल्गोरिदम को इसी शीर्षक के साथ श्रीनिवास एम. अजी और रॉबर्ट जे. मैकएलीस द्वारा अर्ध-संरक्षक में प्रस्तुत किया गया था।<ref name=GenDistLaw />
 
 
==परिचय==
==परिचय==
''गणित में वितरणात्मक नियम गुणा और योग की संक्रियाओं से संबंधित नियम है, जिसे प्रतीकात्मक रूप से कहा गया है, <math> a*(b + c) = a*b + a*c</math>; अर्थात, एकपदी गुणनखंड <math>a</math> द्विपद गुणनखंड <math> b + c </math> के प्रत्येक पद पर वितरित किया जाता है, या अलग से लागू किया जाता है, जिसके परिणामस्वरूप उत्पाद <math> a*b + a*c </math>- होता है" - ब्रिटानिका''<ref name="Britannica">{{cite encyclopedia|title=वितरणात्मक कानून|url=http://www.britannica.com/EBchecked/topic/166204/distributive-law|encyclopedia=Encyclopædia Britannica. Encyclopædia Britannica Online|publisher=Encyclopædia Britannica Inc|accessdate=1 May 2012}}</ref>


गणित में वितरणात्मक कानून गुणा और जोड़ की संक्रियाओं से संबंधित कानून है, जिसे प्रतीकात्मक रूप से कहा गया है, <math> a*(b + c) = a*b + a*c</math>; वह है, एकपदी कारक <math>a</math> द्विपद गुणनखंड के प्रत्येक पद पर वितरित किया जाता है, या अलग से लागू किया जाता है <math> b + c </math>, जिसके परिणामस्वरूप उत्पाद प्राप्त होता है <math> a*b + a*c </math>- ब्रिटानिका<ref name=Britannica>{{cite encyclopedia|title=वितरणात्मक कानून|url=http://www.britannica.com/EBchecked/topic/166204/distributive-law|encyclopedia=Encyclopædia Britannica. Encyclopædia Britannica Online|publisher=Encyclopædia Britannica Inc|accessdate=1 May 2012}}</ref>
जैसा कि परिभाषा से देखा जा सकता है, अंकगणितीय अभिव्यक्ति में वितरणात्मक नियम को लागू करने से इसमें संक्रियाओं की संख्या कम हो जाती है। पूर्व उदाहरण में संक्रियाओं की कुल संख्या तीन <math> a*b + a*c </math>) में दो गुणा और एक जोड़) से घटकर दो हो गई <math> a*(b + c) </math>में एक गुणा और एक जोड़)वितरणात्मक नियम के सामान्यीकरण से तीव्र एल्गोरिदम का बड़ा वर्ग तैयार होता है। इसमें [[फास्ट फूरियर ट्रांसफॉर्म|फास्ट फूरियर परिवर्तन]] और [[विटर्बी एल्गोरिदम]] सम्मिलित हैं।
जैसा कि परिभाषा से देखा जा सकता है, एक अंकगणितीय अभिव्यक्ति में वितरणात्मक कानून को लागू करने से इसमें संक्रियाओं की संख्या कम हो जाती है। पिछले उदाहरण में संक्रियाओं की कुल संख्या तीन से कम हो गई (दो गुणा और एक जोड़)। <math> a*b + a*c </math>) से दो (एक गुणा और एक जोड़) <math> a*(b + c) </math>). वितरणात्मक कानून के सामान्यीकरण से [[तेज़ एल्गोरिदम]] का एक बड़ा परिवार तैयार होता है। इसमें [[फास्ट फूरियर ट्रांसफॉर्म]] और [[विटर्बी एल्गोरिदम]] शामिल हैं।


इसे नीचे दिए गए उदाहरण में अधिक औपचारिक तरीके से समझाया गया है:
इस प्रकार से इसे नीचे दिए गए उदाहरण में अधिक औपचारिक विधि से समझाया गया है:


<math>\alpha(a,\, b) \stackrel{\mathrm{def}}{=} \displaystyle\sum \limits_{c,d,e \in A} f(a, \, c, \, b) \, g(a, \, d, \, e) </math> कहाँ <math>f(\cdot)</math> और <math>g(\cdot)</math> वास्तविक-मूल्यवान कार्य हैं, <math>a,b,c,d,e \in A</math> और <math>|A|=q</math> (कहना)
<math>\alpha(a,\, b) \stackrel{\mathrm{def}}{=} \displaystyle\sum \limits_{c,d,e \in A} f(a, \, c, \, b) \, g(a, \, d, \, e) </math> जहां <math>f(\cdot)</math> और <math>g(\cdot)</math> वास्तविक-मानित फलन हैं, <math>a,b,c,d,e \in A</math> और <math>|A|=q</math> (कहना)


यहां हम स्वतंत्र चरों को हाशिए पर रख रहे हैं (<math>c</math>, <math>d</math>, और <math>e</math>) परिणाम प्राप्त करने के लिए. जब हम कम्प्यूटेशनल जटिलता की गणना कर रहे हैं, तो हम इसे प्रत्येक के लिए देख सकते हैं <math>q^{2}</math> के जोड़े <math>(a,b)</math>, वहाँ हैं <math>q^{3}</math> त्रिक के कारण शर्तें <math>(c,d,e)</math> जिसके मूल्यांकन में भाग लेने की आवश्यकता है <math>\alpha(a,\, b)</math> प्रत्येक चरण में एक जोड़ और एक गुणा होता है। इसलिए, आवश्यक गणनाओं की कुल संख्या है <math>2\cdot q^2 \cdot q^3 = 2q^5</math>. इसलिए उपरोक्त फ़ंक्शन की स्पर्शोन्मुख जटिलता है <math>O(n^5)</math>.
यहां हम परिणाम प्राप्त करने के लिए स्वतंत्र चरों (<math>c</math>, <math>d</math>, और <math>e</math>) को हाशिए पर रख रहे हैं। जब हम कम्प्यूटेशनल जटिलता की गणना कर रहे हैं, तो हम देख सकते हैं कि <math>(a,b)</math> के प्रत्येक <math>q^{2}</math> जोड़े के लिए, त्रिक <math>(c,d,e)</math> के कारण <math>q^{3}</math> पद हैं जिन्हें लेने की आवश्यकता है प्रत्येक चरण में एक योग और एक गुणा के साथ <math>\alpha(a,\, b)</math> के मूल्यांकन में भाग लें है। इसलिए, आवश्यक गणनाओं की कुल संख्या <math>2\cdot q^2 \cdot q^3 = 2q^5</math> हैं। इसलिए उपरोक्त फलन की स्पर्शोन्मुख जटिलता <math>O(n^5)</math> हैं।


यदि हम वितरण नियम को समीकरण के आरएचएस पर लागू करते हैं, तो हमें निम्नलिखित मिलता है:
यदि हम वितरण नियम को समीकरण के आरएचएस पर लागू करते हैं, तो हमें निम्नलिखित मिलता है:


: <math>\alpha(a, \, b) \stackrel{\mathrm{def}}{=}  \displaystyle\sum\limits_{c \in A} f(a, \, c, \, b ) \cdot \sum _{d,\,e \in A} g(a,\,d,\,e) </math>
: <math>\alpha(a, \, b) \stackrel{\mathrm{def}}{=}  \displaystyle\sum\limits_{c \in A} f(a, \, c, \, b ) \cdot \sum _{d,\,e \in A} g(a,\,d,\,e) </math>
इसका अर्थ यह है कि <math>\alpha(a, \, b)</math> एक उत्पाद के रूप में वर्णित किया जा सकता है <math>\alpha_{1}(a,\, b) \cdot \alpha_{2}(a)</math> कहाँ <math> \alpha_{1}(a,b) \stackrel{\mathrm{def}}{=} \displaystyle\sum\limits_{c \in A} f(a, \, c, \, b )</math> और <math>\alpha_{2}(a) \stackrel{\mathrm{def}}{=} \displaystyle\sum\limits_{d,\,e \in A} g(a,\, d, \,e )</math>
अतः इसका अर्थ यह है कि <math>\alpha(a, \, b)</math> को उत्पाद <math>\alpha_{1}(a,\, b) \cdot \alpha_{2}(a)</math> के रूप में वर्णित किया जा सकता है जहां <math> \alpha_{1}(a,b) \stackrel{\mathrm{def}}{=} \displaystyle\sum\limits_{c \in A} f(a, \, c, \, b )</math> और <math>\alpha_{2}(a) \stackrel{\mathrm{def}}{=} \displaystyle\sum\limits_{d,\,e \in A} g(a,\, d, \,e )</math>
अब, जब हम कम्प्यूटेशनल जटिलता की गणना कर रहे हैं, तो हम देख सकते हैं कि वहाँ हैं <math>q^{3}</math> में परिवर्धन <math>\alpha_{1}(a,\, b)</math> और <math>\alpha_{2}(a)</math> प्रत्येक और वहाँ हैं <math>q^2</math> जब हम उत्पाद का उपयोग कर रहे होते हैं तो गुणन <math>\alpha_{1}(a,\, b) \cdot \alpha_{2}(a)</math> मूल्यांकन करना <math>\alpha(a, \, b)</math>. इसलिए, आवश्यक गणनाओं की कुल संख्या है <math>q^3 + q^3 + q^2 = 2q^3 + q^2</math>. इसलिए गणना की स्पर्शोन्मुख जटिलता <math>\alpha(a,b)</math> तक कम कर देता है <math>O(n^{3})</math> से <math>O(n^{5})</math>. यह एक उदाहरण से पता चलता है कि वितरण कानून लागू करने से कम्प्यूटेशनल जटिलता कम हो जाती है जो कि तेज़ एल्गोरिदम की अच्छी विशेषताओं में से एक है।
 
अब, जब हम कम्प्यूटेशनल जटिलता की गणना कर रहे हैं, तो हम देख सकते हैं कि <math>\alpha_{1}(a,\, b)</math> और <math>\alpha_{2}(a)</math> प्रत्येक में <math>q^{3}</math> योग हैं और जब हम होते हैं तो <math>q^2</math> गुणन होते हैं <math>\alpha(a, \, b)</math> का मूल्यांकन करने के लिए उत्पाद <math>\alpha_{1}(a,\, b) \cdot \alpha_{2}(a)</math> का उपयोग करना है। इसलिए, आवश्यक गणनाओं की कुल संख्या <math>q^3 + q^3 + q^2 = 2q^3 + q^2</math> है। इसलिए गणना की स्पर्शोन्मुख जटिलता <math>\alpha(a,b)</math> <math>O(n^{3})</math> से <math>O(n^{5})</math> तक कम कर देता है। यह उदाहरण से ज्ञात होता है कि वितरण नियम लागू करने से कम्प्यूटेशनल जटिलता कम हो जाती है जो कि तीव्र एल्गोरिदम की स्पष्ट विशेषताओं में से है।


==इतिहास==
==इतिहास==


कुछ समस्याएँ जिन्हें हल करने के लिए वितरणात्मक कानून का उपयोग किया गया, उन्हें निम्नानुसार समूहीकृत किया जा सकता है
कुछ समस्याएँ जिन्हें हल करने के लिए वितरणात्मक नियम का उपयोग किया गया, उन्हें निम्नानुसार समूहीकृत किया जा सकता है:


1. डिकोडिंग एल्गोरिदम<br>
1. डिकोडिंग एल्गोरिदम<br>कम घनत्व समता-जांच कोड को डिकोड करने के लिए गैलेजर द्वारा जीडीएल जैसे एल्गोरिदम का उपयोग किया गया था। गैलागर के फलन के आधार पर टान्नर ने टान्नर ग्राफ प्रस्तुत किया और गैलागर के फलन को संदेश पासिंग रूप में व्यक्त किया। टेनर्स ग्राफ़ ने विटरबी एल्गोरिदम को समझाने में भी सहायता की है।
कम घनत्व समता-जांच कोड को डिकोड करने के लिए गैलेजर द्वारा एक जीडीएल जैसे एल्गोरिदम का उपयोग किया गया था। गैलागर के काम के आधार पर टान्नर ने [[टान्नर ग्राफ]] पेश किया और गैलागर के काम को संदेश पासिंग फॉर्म में व्यक्त किया। टेनर्स ग्राफ़ ने विटरबी एल्गोरिथम को समझाने में भी मदद की।


फ़ॉर्नी द्वारा यह देखा गया है कि विटर्बी के [[कन्वेन्शनल कोड]] की अधिकतम संभावना डिकोडिंग में जीडीएल जैसी व्यापकता के एल्गोरिदम का भी उपयोग किया जाता है।
फ़ॉर्नी द्वारा यह देखा गया है कि विटर्बी के कन्वेन्शनल कोड की अधिकतम संभावना डिकोडिंग में जीडीएल जैसी व्यापकता के एल्गोरिदम का भी उपयोग किया जाता है।


2. [[फॉरवर्ड-बैकवर्ड एल्गोरिथम]]<br>
2. [[फॉरवर्ड-बैकवर्ड एल्गोरिथम|फॉरवर्ड-बैकवर्ड एल्गोरिदम]]<br>फॉरवर्ड बैकवर्ड एल्गोरिदम ने [[मार्कोव श्रृंखला]] में स्थितियों को ट्रैक करने के लिए एल्गोरिदम के रूप में सहायता की है। और इसमें भी सामान्यता के जैसे जीडीएल के एल्गोरिदम का उपयोग किया गया था
फॉरवर्ड बैकवर्ड एल्गोरिदम ने [[मार्कोव श्रृंखला]] में राज्यों को ट्रैक करने के लिए एक एल्गोरिदम के रूप में मदद की। और इसमें भी सामान्यता की तरह जीडीएल के एल्गोरिदम का उपयोग किया गया था


3. कृत्रिम बुद्धिमत्ता<br>
3. कृत्रिम बुद्धिमत्ता<br>एआई में कई समस्याओं को हल करने के लिए संधि ट्री की अवधारणा का उपयोग किया गया है। इसके अतिरिक्त बाल्टी उन्मूलन की अवधारणा में कई अवधारणाओं का उपयोग किया गया।
एआई में कई समस्याओं को हल करने के लिए जंक्शन पेड़ों की अवधारणा का उपयोग किया गया है। इसके अलावा [[बाल्टी उन्मूलन]] की अवधारणा में कई अवधारणाओं का उपयोग किया गया।


==एमपीएफ समस्या==
==एमपीएफ समस्या==


एमपीएफ या उत्पाद फ़ंक्शन को हाशिए पर रखना एक सामान्य कम्प्यूटेशनल समस्या है जिसमें विशेष मामले में कई शास्त्रीय समस्याएं शामिल हैं जैसे कि असतत [[हैडामर्ड परिवर्तन]] की गणना, मेमोरी-कम [[चैनल (संचार)]] पर एक [[रैखिक कोड]] की [[अधिकतम संभावना डिकोडिंग]], और [[मैट्रिक्स श्रृंखला गुणन]]। जीडीएल की शक्ति इस तथ्य में निहित है कि यह उन स्थितियों पर लागू होता है जिनमें जोड़ और गुणा को सामान्यीकृत किया जाता है।
इस प्रकार से एमपीएफ या उत्पाद फलन को हाशिए पर रखना सामान्य कम्प्यूटेशनल समस्या है जिसमें विशेष स्थिति में कई शास्त्रीय समस्याएं सम्मिलित हैं जैसे कि असतत [[हैडामर्ड परिवर्तन]] की गणना, मेमोरी-कम चैनल (संचार) पर रैखिक कोड की अधिकतम संभावना डिकोडिंग, और मैट्रिक्स श्रृंखला गुणन है। अतः जीडीएल की शक्ति इस तथ्य में निहित है कि यह उन स्थितियों पर लागू होता है जिनमें योग और गुणा को सामान्यीकृत किया जाता है। इस व्यवहार को समझाने के लिए क्रमविनिमेय अर्ध वलय स्पष्ट संरचना है। इसे समुच्चय पर <math>K</math> ऑपरेटरों के साथ "<math>+</math>" और "<math>.</math>" परिभाषित किया गया है, जहां <math>(K,\, +)</math> और <math>(K,\, .)</math> क्रमविनिमेय मोनोइड हैं और वितरणात्मक नियम निहित है।
इस व्यवहार को समझाने के लिए एक [[क्रमविनिमेय सेमीरिंग]] एक अच्छा ढाँचा है। इसे एक सेट पर परिभाषित किया गया है <math>K</math> ऑपरेटरों के साथ<math>+</math>और<math>.</math>कहाँ <math>(K,\, +)</math> और <math>(K,\, .)</math> एक [[क्रमविनिमेय मोनोइड]] हैं और वितरणात्मक कानून कायम है।


होने देना <math>p_1, \ldots, p_n</math> ऐसे परिवर्तनशील बनें <math>p_1 \in A_1, \ldots, p_n \in A_{n}</math> कहाँ <math>A </math> एक परिमित समुच्चय है और <math>|A_i| = q_i</math>. यहाँ <math>i = 1,\ldots, n</math>. अगर <math>S = \{i_{1}, \ldots, i_{r}\}</math> और <math>S \, \subset \{1,\ldots, n\}</math>, होने देना
मान लीजिए <math>p_1, \ldots, p_n</math> ऐसे परिवर्तनशील <math>p_1 \in A_1, \ldots, p_n \in A_{n}</math> हैं जहां <math>A </math> और <math>|A_i| = q_i</math> परिमित समुच्चय है। जहां <math>i = 1,\ldots, n</math> है। यदि <math>S = \{i_{1}, \ldots, i_{r}\}</math> और <math>S \, \subset \{1,\ldots, n\}</math>, मान लीजिए <math> A_{S}  = A_{i_1} \times \cdots \times A_{i_r} </math>, <math> p_{S} = (p_{i_1},\ldots, p_{i_r})</math>,
<math> A_{S}  = A_{i_1} \times \cdots \times A_{i_r} </math>,
<math> p_{S} = (p_{i_1},\ldots, p_{i_r})</math>,
  <math> q_{S} = |A_{S}|</math>,
<math>\mathbf A  = A_{1} \times \cdots \times A_{n} </math>, और
<math>\mathbf p = \{p_{1}, \ldots, p_{n}\}</math>
होने देना <math>S = \{S_{j}\}_{j=1}^M </math> कहाँ <math>S_{j} \subset \{1, ...\,,n\}</math>. मान लीजिए किसी फ़ंक्शन को इस प्रकार परिभाषित किया गया है <math>\alpha_{i}: A_{S_{i}} \rightarrow R</math>, कहाँ <math>R</math> एक क्रमविनिमेय सेमीरिंग है। भी, <math> p_{S_{i}}</math> स्थानीय डोमेन नाम दिए गए हैं और <math>\alpha_{i}</math> स्थानीय गुठली के रूप में.


अब वैश्विक कर्नेल <math>\beta : \mathbf A \rightarrow R</math> परिभाषित किया जाता है :
<math> q_{S} = |A_{S}|</math>, <math>\mathbf A  = A_{1} \times \cdots \times A_{n} </math>, और <math>\mathbf p = \{p_{1}, \ldots, p_{n}\}</math>
<math> \beta(p_{1}, ...\,, p_{n}) = \prod_{i=1}^M \alpha(p_{S_{i}})</math>
एमपीएफ समस्या की परिभाषा: एक या अधिक सूचकांकों के लिए <math>i = 1, ...\,, M</math>, के मानों की एक तालिका की गणना करें <math>S_{i}</math>-वैश्विक कर्नेल का हाशियाकरण <math>\beta</math>, जो कि कार्य है <math>\beta_{i}:A_{S_{i}} \rightarrow R</math> के रूप में परिभाषित <math>\beta_{i}(p_{S_{i}}) \, = \displaystyle\sum\limits_{p_{S_{i}^c} \in A_{S_{i}^c}} \beta(p)</math>
यहाँ <math>S_{i}^c</math> का पूरक है <math>S_{i}</math> इसके संबंध में <math>\mathbf \{1,...\,,n\}</math> और यह <math>\beta_i(p_{S_i})</math> कहा जाता है <math>i^{th}</math> वस्तुनिष्ठ फलन, या वस्तुनिष्ठ फलन <math>S_i</math>. यह देखा जा सकता है कि की गणना <math>i^{th}</math> स्पष्ट तरीके से वस्तुनिष्ठ कार्य की आवश्यकता है <math>Mq_1 q_2 q_3\cdots q_{n}</math> परिचालन. ऐसा इसलिए है क्योंकि वहाँ हैं <math>q_1 q_2\cdots q_n</math> अतिरिक्त और <math>(M-1)q_1 q_2...q_n</math> की गणना में आवश्यक गुणन <math>i^\text{th}</math> उद्देश्य समारोह। जीडीएल एल्गोरिदम जिसे अगले भाग में समझाया गया है, इस कम्प्यूटेशनल जटिलता को कम कर सकता है।


निम्नलिखित एमपीएफ समस्या का एक उदाहरण है।
मान लीजिए <math>S = \{S_{j}\}_{j=1}^M </math> जहां <math>S_{j} \subset \{1, ...\,,n\}</math> है। मान लीजिए किसी फलन को इस प्रकार परिभाषित किया गया है कि <math>\alpha_{i}: A_{S_{i}} \rightarrow R</math>, जहां <math>R</math> क्रमविनिमेय अर्ध वलय है। साथ ही, <math> p_{S_{i}}</math> को स्थानीय प्रांत और <math>\alpha_{i}</math> को स्थानीय कर्नेल नाम दिया गया है।
होने देना <math>p_{1},\,p_{2},\,p_{3},\,p_{4},</math> और <math>p_{5}</math> ऐसे परिवर्तनशील बनें <math>p_{1} \in A_{1}, p_{2} \in A_{2}, p_{3} \in A_{3}, p_{4} \in A_{4}, </math> और <math>p_{5} \in A_{5}</math>. यहाँ <math>M=4</math> और <math>S = \{\{1,2,5\},\{2,4\},\{1,4\}, \{2\}\}</math>. इन वेरिएबल्स का उपयोग करके दिए गए फ़ंक्शन हैं <math>f(p_{1},p_{2},p_{5})</math> और <math>g(p_{3},p_{4})</math> और हमें गणना करने की आवश्यकता है <math>\alpha(p_{1}, \, p_{4})</math> और <math>\beta(p_{2})</math> के रूप में परिभाषित:
 
इस प्रकार से अब वैश्विक कर्नेल <math>\beta : \mathbf A \rightarrow R</math> को <math> \beta(p_{1}, ...\,, p_{n}) = \prod_{i=1}^M \alpha(p_{S_{i}})</math> के जैसे परिभाषित किया जाता है :
 
एमपीएफ समस्या की परिभाषा: एक या अधिक सूचकांकों <math>i = 1, ...\,, M</math>, के लिए, वैश्विक कर्नेल <math>\beta</math> के <math>S_{i}</math>- हाशियाकरण के मानों की एक तालिका की गणना करें, जो <math>\beta_{i}(p_{S_{i}}) \, = \displaystyle\sum\limits_{p_{S_{i}^c} \in A_{S_{i}^c}} \beta(p)</math> के रूप में परिभाषित फलन <math>\beta_{i}:A_{S_{i}} \rightarrow R</math> है।
 
अतः यहाँ <math>S_{i}^c</math>, <math>\mathbf \{1,...\,,n\}</math> के संबंध में <math>S_{i}</math> का पूरक है और <math>\beta_i(p_{S_i})</math> कों <math>i^{th}</math> उदेश्य फलन, या <math>S_i</math> पर उदेश्य फलन कहा जाता है। यह देखा जा सकता है कि की गणना <math>i^{th}</math> स्पष्ट विधि से उदेश्य फलन <math>Mq_1 q_2 q_3\cdots q_{n}</math> परिचालन की आवश्यकता है। ऐसा इसलिए है क्योंकि <math>i^\text{th}</math> उद्देश्य फलन की गणना में <math>q_1 q_2\cdots q_n</math> योग और <math>(M-1)q_1 q_2...q_n</math> गुणा आवश्यक हैं। जीडीएल एल्गोरिदम जिसे अगले भाग में समझाया गया है, इस कम्प्यूटेशनल जटिलता को कम कर सकता है।
 
निम्नलिखित एमपीएफ समस्या का उदाहरण है। मान लीजिए <math>p_{1},\,p_{2},\,p_{3},\,p_{4},</math> और <math>p_{5}</math> ऐसे चर हैं कि <math>p_{1} \in A_{1}, p_{2} \in A_{2}, p_{3} \in A_{3}, p_{4} \in A_{4}, </math> और <math>p_{5} \in A_{5}</math>यहाँ <math>M=4</math> और <math>S = \{\{1,2,5\},\{2,4\},\{1,4\}, \{2\}\}</math>। इस प्रकार से इन चरों का उपयोग करके दिए गए फलन <math>f(p_{1},p_{2},p_{5})</math> और <math>g(p_{3},p_{4})</math> हैं, और हमें <math>\alpha(p_{1}, \, p_{4})</math> और <math>\beta(p_{2})</math> की गणना इस प्रकार परिभाषित करने की आवश्यकता है:


: <math> \alpha(p_1, \, p_4) =  \displaystyle\sum\limits_{p_2 \in A_2,\, p_3 \in A_3, \, p_5 \in A_5 } f(p_1,\, p_2,\, p_5 ) \cdot g(p_2, \, p_4)</math>
: <math> \alpha(p_1, \, p_4) =  \displaystyle\sum\limits_{p_2 \in A_2,\, p_3 \in A_3, \, p_5 \in A_5 } f(p_1,\, p_2,\, p_5 ) \cdot g(p_2, \, p_4)</math>
: <math> \beta(p_{2}) = \sum\limits_{p_1 \in A_1,\, p_3 \in A_3,\, p_4 \in A_4, \, p_5 \in A_5 } f(p_1, \, p_2, \, p_5) \cdot g(p_2, \, p_4) </math>
: <math> \beta(p_{2}) = \sum\limits_{p_1 \in A_1,\, p_3 \in A_3,\, p_4 \in A_4, \, p_5 \in A_5 } f(p_1, \, p_2, \, p_5) \cdot g(p_2, \, p_4) </math>
यहां स्थानीय डोमेन और स्थानीय कर्नेल को इस प्रकार परिभाषित किया गया है:
इस प्रकार से यहाँ स्थानीय प्रांत और स्थानीय कर्नेल को इस प्रकार परिभाषित किया गया है:
  {|
  {|
|-
|-
! local domains !! local kernels
! स्थानीय प्रांत !! स्थानीय कर्नेल
|-
|-
| <math>\{p_{1}, p_{2}, p_{5}\}</math> || <math>(f(p_{1}, p_{2}, p_{5})</math>
| <math>\{p_{1}, p_{2}, p_{5}\}</math> || <math>(f(p_{1}, p_{2}, p_{5})</math>
Line 70: Line 63:
| <math>\{p_{2}\}</math> || <math>1</math>
| <math>\{p_{2}\}</math> || <math>1</math>
|}
|}
कहाँ <math>\alpha(p_{1}, p_{4})</math> है <math>3^{rd}</math> वस्तुनिष्ठ कार्य और <math>\beta(p_{2})</math> है <math>4^{th}</math> उद्देश्य समारोह।
जहां <math>\alpha(p_{1}, p_{4})</math> <math>3^{rd}</math> का उदेश्य फलन है और <math>\beta(p_{2})</math> <math>4^{th}</math> उदेश्य फलन है।


एक और उदाहरण पर विचार करें जहां <math>p_{1},p_{2},p_{3},p_{4},r_{1},r_{2},r_{3},r_{4} \in \{0,1\}</math> और <math>f(r_{1},r_{2},r_{3},r_{4})</math> एक वास्तविक मूल्यवान कार्य है। अब, हम एमपीएफ समस्या पर विचार करेंगे जहां क्रमविनिमेय सेमीरिंग को सामान्य जोड़ और गुणा के साथ वास्तविक संख्याओं के सेट के रूप में परिभाषित किया गया है और स्थानीय डोमेन और स्थानीय कर्नेल को निम्नानुसार परिभाषित किया गया है:
अतः एक अन्य उदाहरण पर विचार करें जहां <math>p_{1},p_{2},p_{3},p_{4},r_{1},r_{2},r_{3},r_{4} \in \{0,1\}</math> और <math>f(r_{1},r_{2},r_{3},r_{4})</math> एक वास्तविक मानित फलन है। अब, हम एमपीएफ समस्या पर विचार करेंगे जहां क्रमविनिमेय अर्ध वलय को सामान्य योग और गुणा के साथ वास्तविक संख्याओं के समुच्चय के रूप में परिभाषित किया गया है, और स्थानीय प्रांत और स्थानीय कर्नेल को निम्नानुसार परिभाषित किया गया है:


{|
{|
|-
|-
! local domains !! local kernels
! स्थानीय प्रांत !! स्थानीय कर्नेल
|-
|-
| <math>\{r_1, r_2, r_3,r_4\}</math> || <math>f(r_1, r_2, r_3,r_4)</math>
| <math>\{r_1, r_2, r_3,r_4\}</math> || <math>f(r_1, r_2, r_3,r_4)</math>
Line 90: Line 83:
| <math>\{p_1,p_2, p_3, p_4\}</math> || <math>1</math>
| <math>\{p_1,p_2, p_3, p_4\}</math> || <math>1</math>
|}
|}
अब चूंकि वैश्विक कर्नेल को स्थानीय कर्नेल के उत्पाद के रूप में परिभाषित किया गया है, यह है
चूँकि वैश्विक कर्नेल को स्थानीय कर्नेल के उत्पाद के रूप में परिभाषित किया गया है, यह


: <math>F(p_1, p_2, p_3,p_4, r_1, r_2, r_3,r_4) = f(p_1,p_2,p_3,p_4)\cdot(-1)^{p_1r_1 + p_2r_2 + p_3r_3 + p_4r_4}</math>
: <math>F(p_1, p_2, p_3,p_4, r_1, r_2, r_3,r_4) = f(p_1,p_2,p_3,p_4)\cdot(-1)^{p_1r_1 + p_2r_2 + p_3r_3 + p_4r_4}</math>
और स्थानीय डोमेन पर उद्देश्य फ़ंक्शन <math>p_1, p_2, p_3,p_4</math> है
और स्थानीय प्रांत <math>p_1, p_2, p_3,p_4</math> पर उद्देश्य फलन


: <math>F(p_1, p_2, p_3,p_4) = \displaystyle\sum \limits_{r_1,r_2,r_3,r_4} f(r_1,r_2,r_3,r_4) \cdot(-1)^{p_1r_1 + p_2r_2 + p_3r_3 + p_4r_4}.</math>
: <math>F(p_1, p_2, p_3,p_4) = \displaystyle\sum \limits_{r_1,r_2,r_3,r_4} f(r_1,r_2,r_3,r_4) \cdot(-1)^{p_1r_1 + p_2r_2 + p_3r_3 + p_4r_4}.</math> है।
यह फ़ंक्शन का Hadamard रूपांतरण है <math>f(\cdot)</math>. इसलिए हम देख सकते हैं कि हैडामर्ड ट्रांसफॉर्म की गणना एमपीएफ समस्या का एक विशेष मामला है। यह साबित करने के लिए और अधिक उदाहरण प्रदर्शित किए जा सकते हैं कि एमपीएफ समस्या कई शास्त्रीय समस्याओं के विशेष मामले बनाती है जैसा कि ऊपर बताया गया है जिनका विवरण यहां पाया जा सकता है<ref name=GenDistLaw />
इस प्रकार से यह फलन <math>f(\cdot)</math> का हैडामर्ड परिवर्तन है। इसलिए हम देख सकते हैं कि हैडामर्ड परिवर्तन की गणना एमपीएफ समस्या की विशेष स्थिति है। यह सिद्ध करने के लिए और अधिक उदाहरण प्रदर्शित किए जा सकते हैं कि एमपीएफ समस्या कई शास्त्रीय समस्याओं की विशेष स्थिति बनाती है जैसा कि ऊपर बताया गया है, जिनका विवरण यहां पाया जा सकता है।<ref name=GenDistLaw />
== जीडीएल: एमपीएफ समस्या को हल करने के लिए एल्गोरिदम ==


यदि कोई किसी दिए गए समुच्चय के अवयवों <math>S</math> के बीच संबंध पा सकता है, तो कोई विश्वास प्रसार की धारणा के आधार पर एमपीएफ समस्या को हल कर सकता है जो संदेश भेजने की तकनीक का विशेष उपयोग है। आवश्यक संबंध यह है कि स्थानीय प्रांत के दिए गए समुच्चय को संधि ट्री में व्यवस्थित किया जा सकता है। दूसरे शब्दों में, हम ट्री <math>T</math> के शीर्षों के रूप में <math>S</math> के साथ एक ग्राफ सैद्धांतिक ट्री बनाते हैं, जैसे कि किन्हीं दो यादृच्छिक शीर्षों <math>v_{i}</math> और <math>v_{j}</math> कहें जहां <math>i \neq j</math> और एक किनारा स्थित है, इन दो शीर्षों के बीच, फिर संगत लेबलों का प्रतिच्छेदन, अर्थात <math>S_{i}\cap S_{j}</math>, <math>v_{i}</math> को <math>v_{j}</math> तक अद्वितीय पथ पर प्रत्येक शीर्ष पर लेबल का एक उपसमुच्चय है।


== जीडीएल: एमपीएफ समस्या को हल करने के लिए एक एल्गोरिदम ==
इस प्रकार से उदाहरण के लिए,


यदि कोई किसी दिए गए सेट के तत्वों के बीच एक संबंध पा सकता है <math>S</math>, तो कोई विश्वास प्रसार की धारणा के आधार पर एमपीएफ समस्या को हल कर सकता है जो संदेश भेजने की तकनीक का एक विशेष उपयोग है। आवश्यक संबंध यह है कि स्थानीय डोमेन के दिए गए सेट को एक जंक्शन ट्री में व्यवस्थित किया जा सकता है। दूसरे शब्दों में, हम के तत्वों के साथ एक ग्राफ सैद्धांतिक वृक्ष बनाते हैं <math>S</math> पेड़ के शीर्ष के रूप में (ग्राफ सिद्धांत) <math>T</math>, जैसे कि किन्हीं दो मनमाने शीर्षों के लिए कहें <math>v_{i}</math> और <math>v_{j}</math> कहाँ <math>i \neq j</math> और इन दो शीर्षों के बीच एक किनारा मौजूद है, फिर संबंधित लेबलों का प्रतिच्छेदन, अर्थात <math>S_{i}\cap S_{j}</math>, से अद्वितीय पथ पर प्रत्येक शीर्ष पर लेबल का एक उपसमूह है <math>v_{i}</math> को <math>v_{j}</math>.
उदाहरण 1: निम्नलिखित नौ स्थानीय प्रांत पर विचार करें:
 
उदाहरण के लिए,
 
उदाहरण 1: निम्नलिखित नौ स्थानीय डोमेन पर विचार करें:


# <math>\{p_2\}</math>
# <math>\{p_2\}</math>
Line 116: Line 107:
# <math>\{p_4\}</math>
# <math>\{p_4\}</math>
# <math>\{p_2,p_4\}</math>
# <math>\{p_2,p_4\}</math>
ऊपर दिए गए स्थानीय डोमेन के सेट के लिए, कोई उन्हें जंक्शन ट्री में व्यवस्थित कर सकता है जैसा कि नीचे दिखाया गया है:
ऊपर दिए गए स्थानीय प्रांत के समुच्चय के लिए, कोई उन्हें संधि ट्री में व्यवस्थित कर सकता है जैसा कि नीचे दिखाया गया है:


[[File:An example of a junction tree on a given set.png|center|पेड़ के जंक्शन का एक उदाहरण]]इसी प्रकार यदि निम्नलिखित जैसा एक और सेट दिया गया है
[[File:An example of a junction tree on a given set.png|center|ट्री के संधि का उदाहरण|491x491px]]इसी प्रकार यदि निम्नलिखित जैसा और समुच्चय दिया गया है-


उदाहरण 2: निम्नलिखित चार स्थानीय डोमेन पर विचार करें:
उदाहरण 2: निम्नलिखित चार स्थानीय प्रांत पर विचार करें:


# <math>\{p_1,p_2\}</math>
# <math>\{p_1,p_2\}</math>
Line 126: Line 117:
# <math>\{p_3,p_4\}</math>
# <math>\{p_3,p_4\}</math>
# <math>\{p_1,p_4\}</math>
# <math>\{p_1,p_4\}</math>
फिर केवल इन स्थानीय डोमेन के साथ पेड़ का निर्माण संभव नहीं है क्योंकि मूल्यों के इस सेट में कोई सामान्य डोमेन नहीं है जिसे उपरोक्त सेट के किन्हीं दो मानों के बीच रखा जा सके। लेकिन हालाँकि, यदि नीचे दिखाए गए अनुसार दो डमी डोमेन जोड़ें तो अद्यतन सेट को जंक्शन ट्री में व्यवस्थित करना संभव और आसान भी होगा।
फिर मात्र इन स्थानीय प्रांत के साथ ट्री का निर्माण संभव नहीं है क्योंकि मानों के इस समुच्चय में कोई सामान्य प्रांत नहीं है जिसे उपरोक्त समुच्चय के किन्हीं दो मानों के बीच रखा जा सके। परंतु यद्यपि, यदि नीचे दिखाए गए अनुसार दो प्रतिरूप प्रांत जोड़ें तो अद्यतन समुच्चय को संधि ट्री में व्यवस्थित करना संभव और सरल भी होगा।
 
5.<math>\{p_{1},p_{2}</math>,<math>p_{4}\}</math><br/>6.<math>\{p_{2},p_{3}</math>,<math>p_{4}\}</math>


5.<math>\{p_{1},p_{2}</math>,<math>p_{4}\}</math><br/>
अतः इसी प्रकार प्रांत के इन समुच्चय के लिए, संधि ट्री नीचे दिखाए गए जैसा दिखता है:
6.<math>\{p_{2},p_{3}</math>,<math>p_{4}\}</math>
[[File:Example of junction tree.png|center|संधि ट्री का और उदाहरण]]
इसी प्रकार डोमेन के इन सेट के लिए, जंक्शन ट्री नीचे दिखाए गए जैसा दिखता है:
[[File:Example of junction tree.png|center|जंक्शन वृक्ष का एक और उदाहरण]]


===सामान्यीकृत वितरण कानून (जीडीएल) एल्गोरिदम===
===सामान्यीकृत वितरण नियम (जीडीएल) एल्गोरिदम===
इनपुट: स्थानीय डोमेन का एक सेट।<br />
इनपुट: स्थानीय प्रांत का समुच्चय।<br />आउटपुट: प्रांत के दिए गए समुच्चय के लिए, समस्या को हल करने के लिए आवश्यक न्यूनतम संख्या में संक्रिया की गणना की जाती है। <br/>फिर यदि <math>v_{i}</math> और <math>v_{j}</math> संधि ट्री में किनारे से जुड़े होते हैं, फिर संदेश से <math>v_{i}</math> को <math>v_{j}</math> किसी फलन द्वारा दिए गए मानों का समुच्चय/तालिका है: <math>\mu_{i,j}</math>:<math>A_{S_{i}\cap S_{j}} \rightarrow R</math>सभी कार्यों के साथ आरंभ करने के लिए अर्थात सभी संयोजनों के लिए <math>i</math> और <math>j</math> दिए गए ट्री में, <math>\mu_{i,j}</math> को समान रूप से <math>1</math> में परिभाषित किया गया है और जब कोई विशेष संदेश अद्यतन किया जाता है, तो यह नीचे दिए गए समीकरण का पालन करता है।
आउटपुट: डोमेन के दिए गए सेट के लिए, समस्या को हल करने के लिए आवश्यक न्यूनतम संख्या में ऑपरेशन की गणना की जाती है। <br/>
तो यदि <math>v_{i}</math> और <math>v_{j}</math> जंक्शन ट्री में एक किनारे से जुड़े होते हैं, फिर एक संदेश से <math>v_{i}</math> को <math>v_{j}</math> किसी फ़ंक्शन द्वारा दिए गए मानों का एक सेट/तालिका है: <math>\mu_{i,j}</math>:<math>A_{S_{i}\cap S_{j}} \rightarrow R</math>. सभी कार्यों के साथ आरंभ करने के लिए अर्थात सभी संयोजनों के लिए <math>i</math> और <math>j</math> दिए गए पेड़ में, <math>\mu_{i,j}</math> को समान रूप से परिभाषित किया गया है <math>1</math> और जब कोई विशेष संदेश अद्यतन किया जाता है, तो यह नीचे दिए गए समीकरण का पालन करता है।


: <math>\mu_{i,j}(p_{S_{i}\cap S_{j}})</math> = <math>\sum_{p_{S_{i}\setminus S_{j}}\in A_{S_{i} \setminus S_{j}}} \alpha _{i} (p_{S_{i}}) \prod_{{v_k \operatorname{adj} v_i},{k \neq j}} \mu_{k,j}(p_{S_k\cap S_i})(1)
: <math>\mu_{i,j}(p_{S_{i}\cap S_{j}})</math> = <math>\sum_{p_{S_{i}\setminus S_{j}}\in A_{S_{i} \setminus S_{j}}} \alpha _{i} (p_{S_{i}}) \prod_{{v_k \operatorname{adj} v_i},{k \neq j}} \mu_{k,j}(p_{S_k\cap S_i})(1)
  </math>
  </math>
कहाँ <math>v_k \operatorname{adj} v_i</math> मतलब कि <math>v_{k}</math> का निकटवर्ती शीर्ष है <math>v_{i}</math> पेड़ में.
जहां <math>v_k \operatorname{adj} v_i</math> का अर्थ है कि <math>v_{k}</math> ट्री में <math>v_{i}</math> का आसन्न शीर्ष है।


इसी प्रकार प्रत्येक शीर्ष पर एक स्थिति होती है जिसे फ़ंक्शन के मानों वाली तालिका के रूप में परिभाषित किया जाता है <math>\sigma_{i}: A_{S_{i}} \rightarrow R </math>, बिल्कुल वैसे ही जैसे संदेश 1 से प्रारंभ होते हैं, ठीक उसी तरह, की स्थिति <math>v_{i}</math> स्थानीय कर्नेल के रूप में परिभाषित किया गया है <math>\alpha(p_{S_{i}})</math>, लेकिन जब भी <math>\sigma_{i}</math> अद्यतन हो जाता है, यह निम्नलिखित समीकरण का पालन करता है:
इसी प्रकार प्रत्येक शीर्ष पर स्थिति होती है जिसे फलन के मानों वाली तालिका <math>\sigma_{i}: A_{S_{i}} \rightarrow R </math> के रूप में परिभाषित किया जाता है , निश्चित वैसे ही जैसे संदेश 1 से प्रारंभ होते हैं, ठीक उसी प्रकार, <math>v_{i}</math> की स्थिति स्थानीय कर्नेल <math>\alpha(p_{S_{i}})</math> के रूप में परिभाषित किया गया है, परंतु जब भी <math>\sigma_{i}</math> अद्यतन हो जाता है, यह निम्नलिखित समीकरण का पालन करता है:


: <math>\sigma(p_{S_i})  =  \alpha_i(p_{S_i}) \prod_{v_k \operatorname{adj} v_i}  \mu_{k,j}(p_{S_k\cap S_i})(2).</math>
: <math>\sigma(p_{S_i})  =  \alpha_i(p_{S_i}) \prod_{v_k \operatorname{adj} v_i}  \mu_{k,j}(p_{S_k\cap S_i})(2).</math>
===एल्गोरिदम का मूल कार्य===
अतः इनपुट के रूप में स्थानीय प्रांत के दिए गए समुच्चय के लिए, हम यह ज्ञात करते हैं कि क्या हम संधि ट्री बना सकते हैं, या तो प्रत्यक्षतः समुच्चय का उपयोग करके या पहले समुच्चय में प्रतिरूप प्रांत जोड़कर और फिर संधि ट्री बनाकर, यदि निर्माण संधि संभव नहीं है तो एल्गोरिदम आउटपुट देता है कि दिए गए समीकरण समस्या की गणना करने के लिए चरणों की संख्या को कम करने की कोई विधि नहीं है, परंतु बार जब हमारे निकट संधि ट्री होता है, तो एल्गोरिदम को संदेशों को नियोजित करना होगा और स्थितियों की गणना करनी होगी, ऐसा करने से हम जान सकते हैं कि चरणों को कहां कम किया जा सकता है, इसलिए इस पर नीचे चर्चा की जाएगी।


== संदेश भेजने का नियोजन और स्थिति की गणना ==


===एल्गोरिदम का मूल कार्य===
ऐसी दो विशेष स्थिति हैं जिनके विषय में हम यहां बात करने जा रहे हैं, अर्थात् एकल शीर्ष समस्या जिसमें उद्देश्य फलन की गणना मात्र शीर्ष पर की जाती है। इस प्रकार से <math>v_{0}</math> और दूसरा सभी शीर्ष समस्याएँ है जहां लक्ष्य सभी शीर्षों पर उदेश्य फलन की गणना करना है।
इनपुट के रूप में स्थानीय डोमेन के दिए गए सेट के लिए, हम यह पता लगाते हैं कि क्या हम जंक्शन ट्री बना सकते हैं, या तो सीधे सेट का उपयोग करके या पहले सेट में डमी डोमेन जोड़कर और फिर जंक्शन ट्री बनाकर, यदि निर्माण जंक्शन संभव नहीं है तो एल्गोरिदम आउटपुट देता है कि दिए गए समीकरण समस्या की गणना करने के लिए चरणों की संख्या को कम करने का कोई तरीका नहीं है, लेकिन एक बार जब हमारे पास जंक्शन ट्री होता है, तो एल्गोरिदम को संदेशों को शेड्यूल करना होगा और राज्यों की गणना करनी होगी, ऐसा करने से हम जान सकते हैं कि चरणों को कहां कम किया जा सकता है, इसलिए इस पर नीचे चर्चा की जाएगी।


== संदेश भेजने का शेड्यूल और स्थिति की गणना ==
आइए 'एकल-शीर्ष समस्या' से प्रारंभ करें, जीडीएल प्रत्येक किनारे को लक्षित शीर्ष <math>v_0</math> की ओर निर्देशित करके प्रारंभ करेगा। यहां संदेश मात्र लक्षित शीर्ष की दिशा में ही भेजे जाते हैं। ध्यान दें कि सभी निर्देशित संदेश मात्र एक बार भेजे जाते हैं। संदेश लीफ नोड्स (जहां डिग्री 1 है) से प्रारंभ होकर लक्ष्य शीर्ष <math>v_0</math> की ओर बढ़ते हैं। संदेश पत्तियों से उसके माता-पिता तक और फिर वहां से उनके माता-पिता तक और इसी प्रकार तब तक चलता रहता है जब तक कि वह लक्ष्य शीर्ष <math>v_0</math> तक नहीं पहुंच जाता है। लक्ष्य शिखर <math>v_0</math> अपनी स्थिति की गणना तभी करेगा जब उसे अपने सभी निकटवर्तियों से सभी संदेश प्राप्त होंगे। एक बार जब हमें स्थिति मिल जाती है, तो हमें उत्तर मिल जाता है और इसलिए एल्गोरिदम समाप्त हो जाता है।


ऐसे दो विशेष मामले हैं जिनके बारे में हम यहां बात करने जा रहे हैं, अर्थात् सिंगल वर्टेक्स समस्या जिसमें उद्देश्य फ़ंक्शन की गणना केवल एक शीर्ष पर की जाती है। <math>v_{0}</math> और दूसरा ऑल वर्टिसेस समस्या है जहां लक्ष्य सभी शीर्षों पर वस्तुनिष्ठ फ़ंक्शन की गणना करना है।
इस प्रकार से उदाहरण के लिए, आइए ऊपर दिए गए स्थानीय प्रांत के समुच्चय से निर्मित संधि ट्री पर विचार करें, अर्थात उदाहरण 1 से समुच्चय, <br />अब इन प्रांत के लिए शेड्यूलिंग तालिका है (जहां लक्ष्य शीर्ष <math>p_2</math> है)।


आइए 'सिंगल-वर्टेक्स समस्या' से शुरुआत करें, जीडीएल प्रत्येक किनारे को लक्षित शीर्ष की ओर निर्देशित करके शुरू करेगा <math>v_0</math>. यहां संदेश केवल लक्षित शीर्ष की दिशा में ही भेजे जाते हैं। ध्यान दें कि सभी निर्देशित संदेश केवल एक बार भेजे जाते हैं। संदेश लीफ नोड्स (जहां डिग्री 1 है) से शुरू होकर लक्ष्य शीर्ष की ओर बढ़ते हैं <math>v_0</math>. संदेश पत्तियों से उसके माता-पिता तक और फिर वहां से उनके माता-पिता तक और इसी तरह तब तक चलता रहता है जब तक कि वह लक्ष्य शीर्ष तक नहीं पहुंच जाता <math>v_0</math>. लक्ष्य शिखर <math>v_0</math> अपनी स्थिति की गणना तभी करेगा जब उसे अपने सभी पड़ोसियों से सभी संदेश प्राप्त होंगे। एक बार जब हमें स्थिति मिल जाती है, तो हमें उत्तर मिल जाता है और इसलिए एल्गोरिथम समाप्त हो जाता है।
<math>\text{Round                      Message or State Computation} </math><br/><math>1.\mu_{8,4}(p_{4}) = \alpha_{8}(p_{4}) </math><br/><math>2.\mu_{8,4}(p_{4}) = \Sigma_{p_{2}} \alpha_{9}(p_{2},p_{4}) </math><br/><math>3.\mu_{5,2}(p_{3}) = \alpha_{5}(p_{3}) </math><br/><math>4.\mu_{6,3}(p_{1}) = \Sigma_{p_{4}} \alpha_{6}(p_{1},p_{4}) </math><br/><math>5.\mu_{7,3}(p_{1}) = \alpha_{7}(p_{1}) </math><br/><math>6.\mu_{4,2}(p_{3}) = \Sigma_{p_{4}} \alpha_{4}(p_{3},p_{4}).\mu_{8,4}(p_{4}).\mu_{9,4}(p_{4}) </math><br/><math>7.\mu_{3,1}(p_{2}) = \Sigma_{p_{1}} \alpha_{3}(p_{2},p_{1}).\mu_{6,3}(p_{1}).\mu_{7,3}(p_{1}) </math><br/><math>8.\mu_{2,1}(p_{2}) = \Sigma_{p_{3}} \alpha_{2}(p_{3},p_{2}).\mu_{4,2}(p_{3}).\mu_{5,2}(p_{3}) </math><br/><math>9.\sigma_{1}(p_{2}) = \alpha_{1}(p_{2}).\mu_{2,1}(p_{2}).\mu_{3,1}(p_{2})</math>


उदाहरण के लिए, आइए ऊपर दिए गए स्थानीय डोमेन के सेट से निर्मित एक जंक्शन ट्री पर विचार करें, यानी उदाहरण 1 से सेट, <br />अब इन डोमेन के लिए शेड्यूलिंग तालिका है (जहां लक्ष्य शीर्ष है) <math>p_2</math>).
इस प्रकार एकल शीर्ष जीडीएल की जटिलता को इस प्रकार दिखाया जा सकता है-


<math>\text{Round                      Message or State Computation} </math><br/>
<math>\Sigma_{v} d(v)|A_{S_{(v)}}| </math> अंकगणितीय संक्रियाएँ<br />जहां (नोट: उपरोक्त समीकरण का स्पष्टीकरण लेख में बाद में बताया गया है)<br /><math>S(v)</math> <math>v</math> का लेबल है।<br /><math>d(v)</math> की [[डिग्री (ग्राफ सिद्धांत)]] <math>v</math> है (अर्थात् v के निकटवर्ती शीर्षों की संख्या)
<math>1.\mu_{8,4}(p_{4}) = \alpha_{8}(p_{4}) </math><br/>
<math>2.\mu_{8,4}(p_{4}) = \Sigma_{p_{2}} \alpha_{9}(p_{2},p_{4}) </math><br/>
<math>3.\mu_{5,2}(p_{3}) = \alpha_{5}(p_{3}) </math><br/>
<math>4.\mu_{6,3}(p_{1}) = \Sigma_{p_{4}} \alpha_{6}(p_{1},p_{4}) </math><br/>
<math>5.\mu_{7,3}(p_{1}) = \alpha_{7}(p_{1}) </math><br/>
<math>6.\mu_{4,2}(p_{3}) = \Sigma_{p_{4}} \alpha_{4}(p_{3},p_{4}).\mu_{8,4}(p_{4}).\mu_{9,4}(p_{4}) </math><br/>
<math>7.\mu_{3,1}(p_{2}) = \Sigma_{p_{1}} \alpha_{3}(p_{2},p_{1}).\mu_{6,3}(p_{1}).\mu_{7,3}(p_{1}) </math><br/>
<math>8.\mu_{2,1}(p_{2}) = \Sigma_{p_{3}} \alpha_{2}(p_{3},p_{2}).\mu_{4,2}(p_{3}).\mu_{5,2}(p_{3}) </math><br/>
<math>9.\sigma_{1}(p_{2}) = \alpha_{1}(p_{2}).\mu_{2,1}(p_{2}).\mu_{3,1}(p_{2})</math>
इस प्रकार सिंगल वर्टेक्स जीडीएल की जटिलता को इस प्रकार दिखाया जा सकता है


<math>\Sigma_{v} d(v)|A_{S_{(v)}}| </math> अंकगणितीय संक्रियाएँ<br />
'''सभी शीर्ष समस्या''' को हल करने के लिए, हम जीडीएल को कई विधियों से नियोजक कर सकते हैं, उनमें से कुछ समानांतर कार्यान्वयन हैं जहां प्रत्येक समय में, प्रत्येक स्थिति को अपडेट किया जाता है और प्रत्येक संदेश की गणना और ही समय में प्रसारित किया जाता है। इस प्रकार के कार्यान्वयन में स्थिति और संदेश अधिक से अधिक संख्या में चक्कर लगाने के बाद स्थिर हो जाएंगे जो कि ट्री के व्यास के बराबर है। इस बिंदु पर शीर्षों की सभी अवस्थाएँ वांछित उद्देश्य फलन के बराबर होंगी।
कहां (नोट: उपरोक्त समीकरण का स्पष्टीकरण लेख में बाद में बताया गया है)<br />
<math>S(v)</math> का लेबल है <math>v</math>.<br />
<math>d(v)</math> की [[डिग्री (ग्राफ सिद्धांत)]] है <math>v</math> (अर्थात् v के निकटवर्ती शीर्षों की संख्या)।


ऑल-वर्टिसेस समस्या को हल करने के लिए, हम जीडीएल को कई तरीकों से शेड्यूल कर सकते हैं, उनमें से कुछ समानांतर कार्यान्वयन हैं जहां प्रत्येक दौर में, प्रत्येक राज्य को अपडेट किया जाता है और प्रत्येक संदेश की गणना और एक ही समय में प्रसारित किया जाता है। इस प्रकार के कार्यान्वयन में अवस्थाएं और संदेश अधिक से अधिक संख्या में चक्कर लगाने के बाद स्थिर हो जाएंगे जो कि पेड़ के व्यास के बराबर है। इस बिंदु पर शीर्षों की सभी अवस्थाएँ वांछित उद्देश्य फ़ंक्शन के बराबर होंगी।
इस समस्या के लिए जीडीएल को नियोजक करने की दूसरी विधि क्रमिक कार्यान्वयन है, जहां यह एकल शीर्ष समस्या के समान है, इसके अतिरिक्त कि हम एल्गोरिदम को तब तक नहीं रोकते हैं जब तक कि आवश्यक समुच्चय के सभी शीर्षों को अपने सभी निकटवर्तियों से सभी संदेश न मिल जाएं और उनकी स्थिति की गणना न कर लें।<br />इस प्रकार से इस कार्यान्वयन के लिए आवश्यक अंकगणित की संख्या अधिकतम <math>\Sigma_{v \in V} d(v)|A_{S_{(v)}}| </math> अंकगणितीय संक्रिया है।


इस समस्या के लिए जीडीएल को शेड्यूल करने का दूसरा तरीका क्रमिक कार्यान्वयन है जहां यह सिंगल वर्टेक्स समस्या के समान है, सिवाय इसके कि हम एल्गोरिदम को तब तक नहीं रोकते हैं जब तक कि आवश्यक सेट के सभी शीर्षों को अपने सभी पड़ोसियों से सभी संदेश नहीं मिल जाते हैं और उनकी गणना नहीं कर लेते हैं राज्य। <br/>
==संधि ट्री का निर्माण==
इस प्रकार इस कार्यान्वयन के लिए आवश्यक अंकगणित की संख्या अधिकतम है <math>\Sigma_{v \in V} d(v)|A_{S_{(v)}}| </math> अंकगणितीय आपरेशनस।


==जंक्शन ट्री का निर्माण==
संधि ट्री बनाने की कुंजी स्थानीय प्रांत ग्राफ़ <math>G_{LD}</math> में निहित है, जो कि <math>M</math> शीर्षों <math>v_1,v_2,v_3,\ldots ,v_M</math> के साथ एक भारित पूर्ण ग्राफ़ है, अर्थात प्रत्येक स्थानीय प्रांत के लिए एक, जिसमें किनारे <math>e_{i,j} : v_i \leftrightarrow v_j</math> का भार <math>\omega_{i,j} = |S_{i} \cap S_{j}|</math> द्वारा परिभाषित है।<br />यदि <math>x_{k} \in S_{i} \cap S_{j}</math>, तो हम <math>x_{k}</math> कहते हैं जोकि <math>e_{i,j}</math> में निहित है। <math>\omega_{max}</math> द्वारा चिह्नित (अधिकतम भार वाले फैले हुए ट्री का भार <math>G_{LD}</math>), जिसे
 
जंक्शन ट्री बनाने की कुंजी स्थानीय डोमेन ग्राफ़ में निहित है <math>G_{LD}</math>, जो एक भारित पूर्ण ग्राफ़ है <math>M</math> कोने <math>v_1,v_2,v_3,\ldots ,v_M</math> यानी प्रत्येक स्थानीय डोमेन के लिए एक, जिसमें किनारे का भार होता है  <math>e_{i,j} : v_i \leftrightarrow v_j</math> <br /> द्वारा परिभाषित
<math>\omega_{i,j} = |S_{i} \cap S_{j}|</math>.<br />
अगर <math>x_{k} \in S_{i} \cap S_{j}</math>, तो हम कहते हैं <math>x_{k}</math> में निहित है<math>e_{i,j}</math>. द्वारा चिह्नित <math>\omega_{max}</math> (अधिकतम वजन वाले फैले हुए पेड़ का वजन <math>G_{LD}</math>), जिसे परिभाषित किया गया है


: <math>\omega^{*} = \Sigma ^M_{i=1}|S_{i}| - n</math>
: <math>\omega^{*} = \Sigma ^M_{i=1}|S_{i}| - n</math>
जहाँ n उस सेट में तत्वों की संख्या है। अधिक स्पष्टता और विवरण के लिए, कृपया इन्हें देखें।<ref>{{cite web|url=https://ai.stanford.edu/~paskin/gm-short-course/lec3.pdf |title=संग्रहीत प्रति|accessdate=2015-03-19 |url-status=dead |archiveurl=https://web.archive.org/web/20150319085443/https://ai.stanford.edu/~paskin/gm-short-course/lec3.pdf |archivedate=2015-03-19 }} The Junction Tree Algorithms</ref><ref>http://www-anw.cs.umass.edu/~cs691t/SS02/lectures/week7.PDF {{Webarchive|url=https://web.archive.org/web/20120526221700/http://www-anw.cs.umass.edu/~cs691t/SS02/lectures/week7.PDF |date=2012-05-26 }} The Junction Tree Algorithm</ref>
परिभाषित किया गया है, जहाँ n उस समुच्चय में अवयवों की संख्या है। अधिक स्पष्टता और विवरण के लिए, कृपया इन्हें देखें।<ref>{{cite web|url=https://ai.stanford.edu/~paskin/gm-short-course/lec3.pdf |title=संग्रहीत प्रति|accessdate=2015-03-19 |url-status=dead |archiveurl=https://web.archive.org/web/20150319085443/https://ai.stanford.edu/~paskin/gm-short-course/lec3.pdf |archivedate=2015-03-19 }} The Junction Tree Algorithms</ref><ref>http://www-anw.cs.umass.edu/~cs691t/SS02/lectures/week7.PDF {{Webarchive|url=https://web.archive.org/web/20120526221700/http://www-anw.cs.umass.edu/~cs691t/SS02/lectures/week7.PDF |date=2012-05-26 }} The Junction Tree Algorithm</ref>
 
 
== शेड्यूलिंग प्रमेय ==
== शेड्यूलिंग प्रमेय ==


होने देना <math>'T'</math> वर्टेक्स सेट के साथ एक जंक्शन ट्री बनें <math>'V'</math> और किनारा सेट <math>'E'</math>. इस एल्गोरिथ्म में, संदेश किसी भी किनारे पर दोनों दिशाओं में भेजे जाते हैं, इसलिए हम किनारे के सेट E को शीर्षों के क्रमित जोड़े के सेट के रूप में कह/मान सकते हैं। उदाहरण के लिए, चित्र 1 से <math>'E'</math> निम्नानुसार परिभाषित किया जा सकता है
मान लीजिए कि <math>'T'</math> शीर्ष समुच्चय <math>'V'</math> और किनारा समुच्चय <math>'E'</math> के साथ संधि ट्री बनें। इस एल्गोरिदम में, संदेश किसी भी किनारे पर दोनों दिशाओं में भेजे जाते हैं, इसलिए हम किनारे के समुच्चय E को शीर्षों के क्रमित जोड़े के समुच्चय के रूप में कह/मान सकते हैं। इस प्रकार से उदाहरण के लिए, चित्र 1 से <math>'E'</math> निम्नानुसार परिभाषित किया जा सकता है-


: <math>E = \{(1,2),(2,1),(1,3),(3,1),(4,2),(2,4),(5,2),(2,5),(6,3),(3,6),(7,3),(3,7),(8,4),(4,8),(9,4),(4,9)\}</math>
: <math>E = \{(1,2),(2,1),(1,3),(3,1),(4,2),(2,4),(5,2),(2,5),(6,3),(3,6),(7,3),(3,7),(8,4),(4,8),(9,4),(4,9)\}</math>
टिप्पणी:<math>E</math> उपरोक्त आपको वे सभी संभावित दिशा-निर्देश देता है जिनसे एक संदेश पेड़ में फैल सकता है।
टिप्पणी:<math>E</math> उपरोक्त आपको वे सभी संभावित दिशा-निर्देश देता है जिनसे संदेश ट्री में यात्रा सकता है।
 
अतः जीडीएल के लिए नियोजक को उपसमुच्चय के सीमित अनुक्रम <math>E</math> के रूप में परिभाषित किया गया है। जिसका सामान्यतः प्रतिनिधित्व किया जाता है


जीडीएल के लिए शेड्यूल को सबसेट के एक सीमित अनुक्रम के रूप में परिभाषित किया गया है<math>E</math>. जिसका सामान्यतः प्रतिनिधित्व किया जाता है
<math>\mathcal{E} =</math>{<math>E_{1},E_{2},E_{3},\ldots, E_{N}</math>}, जहां <math>E_{N}</math> के समयान अद्यतन किए गए संदेशों <math>N^{th}</math> एल्गोरिदम चलाने के समय का समुच्चय है।
<math>\mathcal{E} =</math>{<math>E_{1},E_{2},E_{3},\ldots, E_{N}</math>}, कहाँ <math>E_{N}</math> के दौरान अद्यतन किए गए संदेशों का सेट है <math>N^{th}</math> एल्गोरिदम चलाने का दौर।


कुछ नोटेशनों को परिभाषित/देखने के बाद, हम देखेंगे कि प्रमेय कहता है,
इस प्रकार से कुछ अंकनों को परिभाषित/देखने के बाद, हम देखेंगे कि प्रमेय कहता है, जब हमें एक नियोजक <math>\mathcal{E} =\{ E_1,E_2,E_3,\ldots, E_N\}</math> दिया जाता है, <math>V \times \{0,1,2,3,\ldots, N\}</math> के शीर्ष समुच्चय के साथ परिमित निर्देशित ग्राफ के रूप में संबंधित [[ सलाखें (ग्राफ) |जालक (ग्राफ)]] है, जिसमें विशिष्ट अवयव <math>v_{i}(t)</math> के लिए <math>t \in \{0,1,2,3,\ldots,N\}</math> को निरूपित किया जाता है, फिर संदेश पारित होने के पूर्ण होने के बाद, शीर्ष <math>v_{j}</math> पर स्थिति
जब हमें एक शेड्यूल दिया जाता है <math>\mathcal{E} =\{ E_1,E_2,E_3,\ldots, E_N\}</math>, वर्टेक्स सेट के साथ एक परिमित निर्देशित ग्राफ के रूप में संबंधित [[ सलाखें (ग्राफ) ]]।  <math>V \times \{0,1,2,3,\ldots, N\}</math>, जिसमें एक विशिष्ट तत्व को निरूपित किया जाता है <math>v_{i}(t)</math> के लिए <math>t \in \{0,1,2,3,\ldots,N\}</math>, फिर संदेश पारित होने के पूरा होने के बाद, शीर्ष पर बताएं <math>v_{j}</math> यह होंगे <math>j^\text{th}</math> उद्देश्य परिभाषित


: <math>\sigma(p_{S_i}) = \alpha_i(p_{S_i}) \prod_{v_k \operatorname{adj} v_i}  \mu_{k,j}(p_{S_{k}\cap S_{i}})</math>
: <math>\sigma(p_{S_i}) = \alpha_i(p_{S_i}) \prod_{v_k \operatorname{adj} v_i}  \mu_{k,j}(p_{S_{k}\cap S_{i}})</math>
और <nowiki>iff</nowiki> से एक रास्ता है <math>v_i(0)</math> को <math>v_j(N)</math>
में परिभाषित <math>j^\text{th}</math> उद्देश्य होगी और यदि <math>v_i(0)</math> से <math>v_j(N)</math> तक कोई पथ है।
 
 
== कम्प्यूटेशनल जटिलता ==
== कम्प्यूटेशनल जटिलता ==


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


उदाहरण: सबसे सरल मामले पर विचार करें जहां हमें निम्नलिखित अभिव्यक्ति की गणना करने की आवश्यकता है <math>ab+ac</math>.
उदाहरण: सबसे सरल स्थिति पर विचार करें जहां हमें निम्नलिखित अभिव्यक्ति <math>ab+ac</math> की गणना करने की आवश्यकता है।


इस अभिव्यक्ति का मूल्यांकन करने के लिए दो गुणा और एक जोड़ की आवश्यकता होती है। अभिव्यक्ति जब वितरणात्मक कानून का उपयोग करके व्यक्त की जाती है तो उसे इस प्रकार लिखा जा सकता है <math>a(b+c)</math> एक सरल अनुकूलन जो संचालन की संख्या को एक जोड़ और एक गुणा तक कम कर देता है।
अतः इस अभिव्यक्ति का मूल्यांकन करने के लिए दो गुणा और योग की आवश्यकता होती है। अभिव्यक्ति जब वितरणात्मक नियम का उपयोग करके व्यक्त की जाती है तो उसे इस प्रकार <math>a(b+c)</math> लिखा जा सकता है, सरल अनुकूलन जो संचालन की संख्या को योग और गुणा तक कम कर देता है।


ऊपर बताए गए उदाहरण के समान हम जीडीएल लागू करके यथासंभव कम ऑपरेशन करने के लिए समीकरणों को विभिन्न रूपों में व्यक्त करेंगे।
इस प्रकार से ऊपर बताए गए उदाहरण के समान हम जीडीएल लागू करके यथासंभव कम संक्रिया करने के लिए समीकरणों को विभिन्न रूपों में व्यक्त करेंगे।


जैसा कि पिछले अनुभागों में बताया गया है, हम जंक्शन पेड़ों की अवधारणा का उपयोग करके समस्या का समाधान करते हैं। इन पेड़ों के उपयोग से प्राप्त अनुकूलन पेड़ों पर अर्ध समूह समस्या को हल करके प्राप्त अनुकूलन के बराबर है। उदाहरण के लिए, संख्याओं के समूह का न्यूनतम ज्ञात करने के लिए हम यह देख सकते हैं कि यदि हमारे पास एक पेड़ है और सभी तत्व पेड़ के नीचे हैं, तो हम समानांतर में दो वस्तुओं के न्यूनतम की तुलना कर सकते हैं और परिणामी न्यूनतम होगा माता-पिता को लिखा गया। जब यह प्रक्रिया पेड़ तक फैलती है तो जड़ में तत्वों का न्यूनतम समूह पाया जाएगा।
जैसा कि पूर्व अनुभागों में बताया गया है, हम संधि ट्री की अवधारणा का उपयोग करके समस्या का हल करते हैं। इन ट्री के उपयोग से प्राप्त अनुकूलन ट्री पर अर्ध समूह समस्या को हल करके प्राप्त अनुकूलन के बराबर है। इस प्रकार से उदाहरण के लिए, संख्याओं के समूह का न्यूनतम ज्ञात करने के लिए हम यह देख सकते हैं कि यदि हमारे निकट ट्री है और सभी अवयव ट्री के नीचे हैं, तो हम समानांतर में दो वस्तुओं के न्यूनतम की तुलना कर सकते हैं और परिणामी न्यूनतम होगा माता-पिता को लिखा गया। जब यह प्रक्रिया ट्री तक फैलती है तो जड़ में अवयवों का न्यूनतम समूह पाया जाएगा।


संदेश पासिंग का उपयोग करके जंक्शन ट्री को हल करने की जटिलता निम्नलिखित है
संदेश पासिंग का उपयोग करके संधि ट्री को हल करने की जटिलता निम्नलिखित है-


हम पहले इस्तेमाल किए गए फॉर्मूले को निम्नलिखित फॉर्म में फिर से लिखते हैं। यह शीर्ष v से w तक भेजे जाने वाले संदेश का समीकरण है
हम पहले उपयोग किए गए सूत्र को निम्नलिखित रूप में फिर से लिखते हैं। यह शीर्ष v से w


: <math>\mu _{v,w} (p_{v \cap w}) =  \sum _{p _{v \setminus w} \in A _{S(v) \setminus S(w)}} \alpha _{v} (p _{v})  \prod _{u adj v _{u \neq v}} \mu _{u,v} (p _{u \cap v})</math> ----संदेश समीकरण
: <math>\mu _{v,w} (p_{v \cap w}) =  \sum _{p _{v \setminus w} \in A _{S(v) \setminus S(w)}} \alpha _{v} (p _{v})  \prod _{u adj v _{u \neq v}} \mu _{u,v} (p _{u \cap v})</math> तक भेजे जाने वाले संदेश का समीकरण है, ----संदेश समीकरण
   
   
इसी प्रकार हम शीर्ष v की स्थिति की गणना के लिए समीकरण को निम्नानुसार फिर से लिखते हैं
इसी प्रकार हम शीर्ष v की स्थिति की गणना के लिए समीकरण को


: <math>\sigma_v(p_v) =  \alpha_v (p_v) \prod_{u \operatorname{adj} v} \mu _{v,w} (p _{v \cap w}) </math>
: <math>\sigma_v(p_v) =  \alpha_v (p_v) \prod_{u \operatorname{adj} v} \mu _{v,w} (p _{v \cap w}) </math>
हम पहले एकल-शीर्ष समस्या का विश्लेषण करेंगे और मान लेंगे कि लक्ष्य शीर्ष है <math>v_0</math> और इसलिए हमारे पास एक किनारा है <math>v</math> को <math>v _{0}</math>.
:के अनुसार फिर से लिखते हैं।
मान लीजिए हमारे पास बढ़त है <math>(v,w)</math> हम संदेश समीकरण का उपयोग करके संदेश की गणना करते हैं। की गणना करना <math>p _{u \cap v}</math> आवश्यक है
हम पहले एकल-शीर्ष समस्या का विश्लेषण करेंगे और मान लेंगे कि लक्ष्य शीर्ष <math>v_0</math> है और इसलिए हमारे निकट <math>v</math>से <math>v _{0}</math> किनारा है।
 
इस प्रकार से मान लीजिए हमारे निकट बढ़त <math>(v,w)</math> है, हम संदेश समीकरण का उपयोग करके संदेश की गणना करते हैं। <math>p _{u \cap v}</math> की गणना करने के लिए


: <math> q _{v \setminus w} -1 </math>
: <math> q _{v \setminus w} -1 </math>
अतिरिक्त और
परिवर्धन और


: <math> q _{v \setminus w} (d(v)-1)</math>
: <math> q _{v \setminus w} (d(v)-1)</math>
गुणन.
गुणन की आवश्यकता होती है।
 
(हम <math>|A _{S(v) \ S(w)}|</math> को <math>q _{v \setminus w}</math>के रूप में दर्शाते हैं।)


(हम इसका प्रतिनिधित्व करते हैं <math>|A _{S(v) \ S(w)}|</math> जैसा <math>q _{v \setminus w}</math>.)
परंतु <math>x _{v \cap w}</math> के लिए कई संभावनाएं होंगी इसलिए <br />


लेकिन इसके लिए कई संभावनाएं होंगी <math>x _{v \cap w}</math> इसलिए <br />
<math> q _{v \cap w} \stackrel{\mathrm{def}}{=} | A _{S(v) \cap S(w)}|</math> <math>p _{v \cap w}</math> के लिए संभावनाएं हैं।
<math> q _{v \cap w} \stackrel{\mathrm{def}}{=} | A _{S(v) \cap S(w)}|</math> के लिए संभावनाएं <math>p _{v \cap w}</math>.
 
इस प्रकार पूरे संदेश की आवश्यकता होगी
इस प्रकार पूर्ण संदेश को


: <math> (q _{v \cap w})(q _{v \setminus w} -1)  = q _{v} - q _{v \cap w}</math>
: <math> (q _{v \cap w})(q _{v \setminus w} -1)  = q _{v} - q _{v \cap w}</math>
अतिरिक्त और
परिवर्धन और


: <math> (q _{v \cap w}) q _{v \setminus w}. (d(v) -1) = (d(v) -1) q _v</math>
: <math> (q _{v \cap w}) q _{v \setminus w}. (d(v) -1) = (d(v) -1) q _v</math>
गुणा
गुणन की आवश्यकता होगी।


एक संदेश भेजने के लिए आवश्यक अंकगणितीय संक्रियाओं की कुल संख्या <math>v_0 </math>पेड़ के किनारों के साथ होगा
ट्री के किनारों के साथ <math>v_0 </math> की ओर एक संदेश भेजने के लिए आवश्यक अंकगणितीय संक्रियाओं की कुल संख्या


: <math>\sum _{ v \neq v0} (q_v - q _{v \cap w})</math>
: <math>\sum _{ v \neq v0} (q_v - q _{v \cap w})</math>
अतिरिक्त और
जोड़ और


: <math> \sum _{ v \neq v0}  (d(v) - 1) q_v</math>
: <math> \sum _{ v \neq v0}  (d(v) - 1) q_v</math>
गुणन.
गुणन होगी।
 
एक बार जब सभी संदेश प्रसारित हो जाते हैं तो एल्गोरिदम स्थिति की गणना <math>v_0</math> के साथ समाप्त हो जाता है, स्थिति गणना <math>d(v_0) q _0</math> की अधिक गुणन आवश्यकता है।


एक बार जब सभी संदेश प्रसारित हो जाते हैं तो एल्गोरिदम स्थिति की गणना के साथ समाप्त हो जाता है <math>v_0</math> राज्य गणना की आवश्यकता है <math>d(v_0) q _0</math> अधिक गुणन.
इस प्रकार स्थिति की गणना के लिए आवश्यक गणनाओं की संख्या नीचे
राज्य की गणना के लिए आवश्यक गणनाओं की संख्या नीचे दी गई है
: <math> \sum _{v \neq v _{0}} (q _{v} - q _{v \cap w}) </math>
: <math> \sum _{v \neq v _{0}} (q _{v} - q _{v \cap w}) </math>
अतिरिक्त और
जोड़ और


: <math> \sum _{v \neq v _{0}} (d(v) -1) q _{v} + d(v _{0})q _{v _{0}}</math>
: <math> \sum _{v \neq v _{0}} (d(v) -1) q _{v} + d(v _{0})q _{v _{0}}</math>
गुणा
गुणन के रूप में दी गई है।


इस प्रकार गणनाओं की संख्या का कुल योग है
इस प्रकार गणनाओं की संख्या का कुल योग


: <math> \chi (T) = \sum _{v \in V} d(v)q _{v} - \sum _{e \in E} q _{e}</math> ----<math>(1)</math>
: <math> \chi (T) = \sum _{v \in V} d(v)q _{v} - \sum _{e \in E} q _{e}</math> ----<math>(1)</math>
कहाँ <math>e = (v,w)</math> एक किनारा है और इसका आकार इससे परिभाषित होता है <math>q _{v \cap w}</math>
है जहां <math>e = (v,w)</math> एक किनारा है और इसका आकार <math>q _{v \cap w}</math> द्वारा परिभाषित किया गया है।
 
उपरोक्त सूत्र हमें ऊपरी सीमा देता है।
उपरोक्त सूत्र हमें ऊपरी सीमा देता है।


यदि हम किनारे की जटिलता को परिभाषित करते हैं <math>e = (v,w)</math> जैसा
यदि हम किनारे की जटिलता को <math>e = (v,w)</math> परिभाषित करते हैं जैसा कि


: <math> \chi (e) = q _{v} + q _{w} - q _{v \cap w} </math>
: <math> \chi (e) = q _{v} + q _{w} - q _{v \cap w} </math>
इसलिए, <math>(1)</math> के रूप में लिखा जा सकता है
है, इसलिए, <math>(1)</math> को


: <math> \chi(T) = \sum _{e \in E} \chi (e)</math>
: <math> \chi(T) = \sum _{e \in E} \chi (e)</math>
अब हम चित्र 1 में परिभाषित समस्या के लिए किनारे की जटिलता की गणना निम्नानुसार करते हैं
:के रूप में लिखा जा सकता है।
अतः अब हम चित्र 1 में परिभाषित समस्या के लिए किनारे की जटिलता की गणना


: <math> \chi(1,2) = q_2 + q_2 q_3 - q_2</math>
: <math> \chi(1,2) = q_2 + q_2 q_3 - q_2</math>
Line 287: Line 263:
: <math> \chi(3,7) = q_1 + q_1 q_2 - q_1</math>
: <math> \chi(3,7) = q_1 + q_1 q_2 - q_1</math>
: <math> \chi(3,6) = q_1 q _4 + q _1 q_2 - q _1</math>
: <math> \chi(3,6) = q_1 q _4 + q _1 q_2 - q _1</math>
पूरी जटिलता होगी <math> 3 q _{2}q _{3} + 3q _{3}q _{4}+ 3 q _{1}q _{2}+q _{2}q _{4} + q _{1}q _{4} - q _{1} - q _{3} - q _{4}</math> जो प्रत्यक्ष विधि की तुलना में काफी कम है। (यहां प्रत्यक्ष विधि से हमारा मतलब उन तरीकों से है जो संदेश भेजने का उपयोग नहीं करते हैं। प्रत्यक्ष विधि का उपयोग करने में लगने वाला समय प्रत्येक नोड पर संदेश की गणना करने और प्रत्येक नोड की स्थिति की गणना करने के समय के बराबर होगा।)
:के अनुसार करते हैं।
इस प्रकार से कुल जटिलता <math> 3 q _{2}q _{3} + 3q _{3}q _{4}+ 3 q _{1}q _{2}+q _{2}q _{4} + q _{1}q _{4} - q _{1} - q _{3} - q _{4}</math> होगी जो प्रत्यक्ष विधि की तुलना में अत्यधिक कम है। (यहां प्रत्यक्ष विधि से हमारा तात्पर्य उन विधियों से है जो संदेश भेजने का उपयोग नहीं करते हैं। प्रत्यक्ष विधि का उपयोग करने में लगने वाला समय प्रत्येक नोड पर संदेश की गणना करने और प्रत्येक नोड की स्थिति की गणना करने के समय के बराबर होगा।)
 
अतः अब हम कुल-शीर्ष समस्या पर विचार करते हैं जहां संदेश को दोनों दिशाओं में भेजना होगा और दोनों शीर्षों पर स्थिति की गणना करनी होगी। ये <math> O( \sum _{v} d(v) d(v) q _{v}) </math> लगेगा, परंतु पूर्व कंप्यूटिंग द्वारा हम गुणन की संख्या <math>3(d-2)</math> को कम कर सकते हैं। यहाँ <math>d</math> शीर्ष की घात है। उदाहरणार्थ: यदि कोई <math> d </math>संख्याओं के साथ समुच्चय <math>(a _{1}, \ldots ,a _{d})</math> है। स्पष्ट <math> d(d-2) </math> के अतिरिक्त अधिकतम <math>3(d-2)</math> गुणन के साथ <math>d-1</math> के <math> a _{i}</math> के सभी d उत्पादों की गणना करना संभव है।
 
हम यह मात्रा


अब हम ऑल-वर्टेक्स समस्या पर विचार करते हैं जहां संदेश को दोनों दिशाओं में भेजना होगा और दोनों शीर्षों पर स्थिति की गणना करनी होगी। ये लगेगा <math> O( \sum _{v} d(v) d(v) q _{v}) </math> लेकिन प्रीकंप्यूटिंग द्वारा हम गुणन की संख्या को कम कर सकते हैं <math>3(d-2)</math>. यहाँ <math>d</math> शीर्ष की डिग्री है. उदाहरणार्थ: यदि कोई समुच्चय है <math>(a _{1}, \ldots ,a _{d})</math> साथ <math> d </math> नंबर. के सभी d उत्पादों की गणना करना संभव है <math>d-1</math> की <math> a _{i}</math> अधिक से अधिक के साथ <math>3(d-2)</math> स्पष्ट के बजाय गुणा <math> d(d-2) </math>.
<math>b_1 = a_1, b_2= b_1 \cdot a_2 = a_1 \cdot a _2, b _{d-1} = b _{d-2} \cdot a_{d-1} = a_1 a_2 \cdots a_{d-1}</math> और <math>c_d = a_d, c_{d-1} = a_{d-1} c_d = a _{d-1} \cdot a_d, \ldots , c_2 = a _2 \cdot c_3 = a _2 a_3 \cdots a_d</math> की पूर्व-गणना करके ऐसा करते हैं, इसमें <math> 2 (d-2)</math> गुणन होता है। फिर यदि <math> m_j</math>, <math> a_j</math> को छोड़कर सभी <math> a_i</math> के गुणनफल को दर्शाता है तो हमारे निकट <math> m_1 = c_2, m_2 = b_1 \cdot c_3</math> है, और इसी प्रकार कुल <math>d-2</math> बनाने के लिए अन्य <math> 3 (d-2)</math> गुणन की आवश्यकता होगी।
हम मात्राओं की पूर्व-गणना करके ऐसा करते हैं
<math>b_1 = a_1, b_2= b_1 \cdot a_2 = a_1 \cdot a _2, b _{d-1} = b _{d-2} \cdot a_{d-1} = a_1 a_2 \cdots a_{d-1}</math> और <math>c_d = a_d, c_{d-1} = a_{d-1} c_d = a _{d-1} \cdot a_d, \ldots , c_2 = a _2 \cdot c_3 = a _2 a_3 \cdots a_d</math> यह लेता है <math> 2 (d-2)</math> गुणन. तो अगर <math> m_j</math> सभी के उत्पाद को दर्शाता है <math> a_i</math> के अलावा <math> a_j</math> हमारे पास है <math> m_1 = c_2, m_2 = b_1 \cdot c_3</math> और इसी तरह दूसरे की आवश्यकता होगी <math>d-2</math> गुणन से कुल बनता है <math> 3 (d-2)</math>
जब जंक्शन ट्री के निर्माण की बात आती है तो हम बहुत कुछ नहीं कर सकते हैं, सिवाय इसके कि हमारे पास कई अधिकतम वजन वाले स्पैनिंग ट्री हो सकते हैं और हमें सबसे कम वजन वाले स्पैनिंग ट्री का चयन करना चाहिए। <math>\chi(T)</math> और कभी-कभी इसका मतलब जंक्शन ट्री जटिलता को कम करने के लिए एक स्थानीय डोमेन जोड़ना हो सकता है।


ऐसा लग सकता है कि GDL तभी सही है जब स्थानीय डोमेन को जंक्शन ट्री के रूप में व्यक्त किया जा सकता है। लेकिन ऐसे मामलों में भी जहां चक्र और कई पुनरावृत्तियां हैं, संदेश लगभग उद्देश्य फ़ंक्शन के बराबर होंगे। कम घनत्व समता-जांच कोड के लिए गैलेजर-टान्नर-वाइबर्ग एल्गोरिदम पर प्रयोग इस दावे का समर्थन करते थे।
जब संधि ट्री के निर्माण की बात आती है तो हम बहुत कुछ नहीं कर सकते हैं, अतिरिक्त इसके कि हमारे निकट कई अधिकतम भार वाले स्पैनिंग ट्री हो सकते हैं और हमें सबसे कम भार वाले विस्तरित ट्री का चयन करना चाहिए। <math>\chi(T)</math> और कभी-कभी इसका तात्पर्य संधि ट्री जटिलता को कम करने के लिए स्थानीय प्रांत जोड़ना हो सकता है।


{{more footnotes|date=June 2012}}
अतः ऐसा लग सकता है कि GDL तभी उचित है जब स्थानीय प्रांत को संधि ट्री के रूप में व्यक्त किया जा सकता है। परंतु ऐसी स्थितियोन में भी जहां चक्र और कई पुनरावृत्तियां हैं, संदेश लगभग उद्देश्य फलन के बराबर होंगे। कम घनत्व समता-जांच कोड के लिए गैलेजर-टान्नर-वाइबर्ग एल्गोरिदम पर प्रयोग इस अनुरोध का समर्थन करते थे।
{{more citations needed|date=June 2012}}


==संदर्भ==
==संदर्भ==
Line 307: Line 284:
[[Category: Machine Translated Page]]
[[Category: Machine Translated Page]]
[[Category:Created On 16/08/2023]]
[[Category:Created On 16/08/2023]]
[[Category:Vigyan Ready]]

Latest revision as of 10:15, 1 December 2023

सामान्यीकृत वितरण नियम (जीडीएल) वितरण गुण का एक ऐसा सामान्यीकरण है जो सामान्य संदेश देना एल्गोरिदम को जन्म देता है।[1] यह सूचना सिद्धांत, डिजिटल संचार, संकेत आगे बढ़ाना, सांख्यिकी और कृत्रिम बुद्धिमत्ता समुदायों में कई लेखकों के फलन का संश्लेषण है। अतः नियम और एल्गोरिदम को इसी शीर्षक के साथ श्रीनिवास एम. अजी और रॉबर्ट जे. मैकएलीस द्वारा अर्ध-संरक्षक में प्रस्तुत किया गया था।[1]

परिचय

गणित में वितरणात्मक नियम गुणा और योग की संक्रियाओं से संबंधित नियम है, जिसे प्रतीकात्मक रूप से कहा गया है, ; अर्थात, एकपदी गुणनखंड द्विपद गुणनखंड के प्रत्येक पद पर वितरित किया जाता है, या अलग से लागू किया जाता है, जिसके परिणामस्वरूप उत्पाद - होता है" - ब्रिटानिका[2]

जैसा कि परिभाषा से देखा जा सकता है, अंकगणितीय अभिव्यक्ति में वितरणात्मक नियम को लागू करने से इसमें संक्रियाओं की संख्या कम हो जाती है। पूर्व उदाहरण में संक्रियाओं की कुल संख्या तीन ) में दो गुणा और एक जोड़) से घटकर दो हो गई में एक गुणा और एक जोड़)। वितरणात्मक नियम के सामान्यीकरण से तीव्र एल्गोरिदम का बड़ा वर्ग तैयार होता है। इसमें फास्ट फूरियर परिवर्तन और विटर्बी एल्गोरिदम सम्मिलित हैं।

इस प्रकार से इसे नीचे दिए गए उदाहरण में अधिक औपचारिक विधि से समझाया गया है:

जहां और वास्तविक-मानित फलन हैं, और (कहना)

यहां हम परिणाम प्राप्त करने के लिए स्वतंत्र चरों (, , और ) को हाशिए पर रख रहे हैं। जब हम कम्प्यूटेशनल जटिलता की गणना कर रहे हैं, तो हम देख सकते हैं कि के प्रत्येक जोड़े के लिए, त्रिक के कारण पद हैं जिन्हें लेने की आवश्यकता है प्रत्येक चरण में एक योग और एक गुणा के साथ के मूल्यांकन में भाग लें है। इसलिए, आवश्यक गणनाओं की कुल संख्या हैं। इसलिए उपरोक्त फलन की स्पर्शोन्मुख जटिलता हैं।

यदि हम वितरण नियम को समीकरण के आरएचएस पर लागू करते हैं, तो हमें निम्नलिखित मिलता है:

अतः इसका अर्थ यह है कि को उत्पाद के रूप में वर्णित किया जा सकता है जहां और

अब, जब हम कम्प्यूटेशनल जटिलता की गणना कर रहे हैं, तो हम देख सकते हैं कि और प्रत्येक में योग हैं और जब हम होते हैं तो गुणन होते हैं का मूल्यांकन करने के लिए उत्पाद का उपयोग करना है। इसलिए, आवश्यक गणनाओं की कुल संख्या है। इसलिए गणना की स्पर्शोन्मुख जटिलता से तक कम कर देता है। यह उदाहरण से ज्ञात होता है कि वितरण नियम लागू करने से कम्प्यूटेशनल जटिलता कम हो जाती है जो कि तीव्र एल्गोरिदम की स्पष्ट विशेषताओं में से है।

इतिहास

कुछ समस्याएँ जिन्हें हल करने के लिए वितरणात्मक नियम का उपयोग किया गया, उन्हें निम्नानुसार समूहीकृत किया जा सकता है:

1. डिकोडिंग एल्गोरिदम
कम घनत्व समता-जांच कोड को डिकोड करने के लिए गैलेजर द्वारा जीडीएल जैसे एल्गोरिदम का उपयोग किया गया था। गैलागर के फलन के आधार पर टान्नर ने टान्नर ग्राफ प्रस्तुत किया और गैलागर के फलन को संदेश पासिंग रूप में व्यक्त किया। टेनर्स ग्राफ़ ने विटरबी एल्गोरिदम को समझाने में भी सहायता की है।

फ़ॉर्नी द्वारा यह देखा गया है कि विटर्बी के कन्वेन्शनल कोड की अधिकतम संभावना डिकोडिंग में जीडीएल जैसी व्यापकता के एल्गोरिदम का भी उपयोग किया जाता है।

2. फॉरवर्ड-बैकवर्ड एल्गोरिदम
फॉरवर्ड बैकवर्ड एल्गोरिदम ने मार्कोव श्रृंखला में स्थितियों को ट्रैक करने के लिए एल्गोरिदम के रूप में सहायता की है। और इसमें भी सामान्यता के जैसे जीडीएल के एल्गोरिदम का उपयोग किया गया था

3. कृत्रिम बुद्धिमत्ता
एआई में कई समस्याओं को हल करने के लिए संधि ट्री की अवधारणा का उपयोग किया गया है। इसके अतिरिक्त बाल्टी उन्मूलन की अवधारणा में कई अवधारणाओं का उपयोग किया गया।

एमपीएफ समस्या

इस प्रकार से एमपीएफ या उत्पाद फलन को हाशिए पर रखना सामान्य कम्प्यूटेशनल समस्या है जिसमें विशेष स्थिति में कई शास्त्रीय समस्याएं सम्मिलित हैं जैसे कि असतत हैडामर्ड परिवर्तन की गणना, मेमोरी-कम चैनल (संचार) पर रैखिक कोड की अधिकतम संभावना डिकोडिंग, और मैट्रिक्स श्रृंखला गुणन है। अतः जीडीएल की शक्ति इस तथ्य में निहित है कि यह उन स्थितियों पर लागू होता है जिनमें योग और गुणा को सामान्यीकृत किया जाता है। इस व्यवहार को समझाने के लिए क्रमविनिमेय अर्ध वलय स्पष्ट संरचना है। इसे समुच्चय पर ऑपरेटरों के साथ "" और "" परिभाषित किया गया है, जहां और क्रमविनिमेय मोनोइड हैं और वितरणात्मक नियम निहित है।

मान लीजिए ऐसे परिवर्तनशील हैं जहां और परिमित समुच्चय है। जहां है। यदि और , मान लीजिए , ,

, , और

मान लीजिए जहां है। मान लीजिए किसी फलन को इस प्रकार परिभाषित किया गया है कि , जहां क्रमविनिमेय अर्ध वलय है। साथ ही, को स्थानीय प्रांत और को स्थानीय कर्नेल नाम दिया गया है।

इस प्रकार से अब वैश्विक कर्नेल को के जैसे परिभाषित किया जाता है :

एमपीएफ समस्या की परिभाषा: एक या अधिक सूचकांकों , के लिए, वैश्विक कर्नेल के - हाशियाकरण के मानों की एक तालिका की गणना करें, जो के रूप में परिभाषित फलन है।

अतः यहाँ , के संबंध में का पूरक है और कों उदेश्य फलन, या पर उदेश्य फलन कहा जाता है। यह देखा जा सकता है कि की गणना स्पष्ट विधि से उदेश्य फलन परिचालन की आवश्यकता है। ऐसा इसलिए है क्योंकि उद्देश्य फलन की गणना में योग और गुणा आवश्यक हैं। जीडीएल एल्गोरिदम जिसे अगले भाग में समझाया गया है, इस कम्प्यूटेशनल जटिलता को कम कर सकता है।

निम्नलिखित एमपीएफ समस्या का उदाहरण है। मान लीजिए और ऐसे चर हैं कि और । यहाँ और । इस प्रकार से इन चरों का उपयोग करके दिए गए फलन और हैं, और हमें और की गणना इस प्रकार परिभाषित करने की आवश्यकता है:

इस प्रकार से यहाँ स्थानीय प्रांत और स्थानीय कर्नेल को इस प्रकार परिभाषित किया गया है:

स्थानीय प्रांत स्थानीय कर्नेल

जहां का उदेश्य फलन है और उदेश्य फलन है।

अतः एक अन्य उदाहरण पर विचार करें जहां और एक वास्तविक मानित फलन है। अब, हम एमपीएफ समस्या पर विचार करेंगे जहां क्रमविनिमेय अर्ध वलय को सामान्य योग और गुणा के साथ वास्तविक संख्याओं के समुच्चय के रूप में परिभाषित किया गया है, और स्थानीय प्रांत और स्थानीय कर्नेल को निम्नानुसार परिभाषित किया गया है:

स्थानीय प्रांत स्थानीय कर्नेल

चूँकि वैश्विक कर्नेल को स्थानीय कर्नेल के उत्पाद के रूप में परिभाषित किया गया है, यह

और स्थानीय प्रांत पर उद्देश्य फलन

है।

इस प्रकार से यह फलन का हैडामर्ड परिवर्तन है। इसलिए हम देख सकते हैं कि हैडामर्ड परिवर्तन की गणना एमपीएफ समस्या की विशेष स्थिति है। यह सिद्ध करने के लिए और अधिक उदाहरण प्रदर्शित किए जा सकते हैं कि एमपीएफ समस्या कई शास्त्रीय समस्याओं की विशेष स्थिति बनाती है जैसा कि ऊपर बताया गया है, जिनका विवरण यहां पाया जा सकता है।[1]

जीडीएल: एमपीएफ समस्या को हल करने के लिए एल्गोरिदम

यदि कोई किसी दिए गए समुच्चय के अवयवों के बीच संबंध पा सकता है, तो कोई विश्वास प्रसार की धारणा के आधार पर एमपीएफ समस्या को हल कर सकता है जो संदेश भेजने की तकनीक का विशेष उपयोग है। आवश्यक संबंध यह है कि स्थानीय प्रांत के दिए गए समुच्चय को संधि ट्री में व्यवस्थित किया जा सकता है। दूसरे शब्दों में, हम ट्री के शीर्षों के रूप में के साथ एक ग्राफ सैद्धांतिक ट्री बनाते हैं, जैसे कि किन्हीं दो यादृच्छिक शीर्षों और कहें जहां और एक किनारा स्थित है, इन दो शीर्षों के बीच, फिर संगत लेबलों का प्रतिच्छेदन, अर्थात , को तक अद्वितीय पथ पर प्रत्येक शीर्ष पर लेबल का एक उपसमुच्चय है।

इस प्रकार से उदाहरण के लिए,

उदाहरण 1: निम्नलिखित नौ स्थानीय प्रांत पर विचार करें:

ऊपर दिए गए स्थानीय प्रांत के समुच्चय के लिए, कोई उन्हें संधि ट्री में व्यवस्थित कर सकता है जैसा कि नीचे दिखाया गया है:

ट्री के संधि का उदाहरण

इसी प्रकार यदि निम्नलिखित जैसा और समुच्चय दिया गया है-

उदाहरण 2: निम्नलिखित चार स्थानीय प्रांत पर विचार करें:

फिर मात्र इन स्थानीय प्रांत के साथ ट्री का निर्माण संभव नहीं है क्योंकि मानों के इस समुच्चय में कोई सामान्य प्रांत नहीं है जिसे उपरोक्त समुच्चय के किन्हीं दो मानों के बीच रखा जा सके। परंतु यद्यपि, यदि नीचे दिखाए गए अनुसार दो प्रतिरूप प्रांत जोड़ें तो अद्यतन समुच्चय को संधि ट्री में व्यवस्थित करना संभव और सरल भी होगा।

5.,
6.,

अतः इसी प्रकार प्रांत के इन समुच्चय के लिए, संधि ट्री नीचे दिखाए गए जैसा दिखता है:

संधि ट्री का और उदाहरण

सामान्यीकृत वितरण नियम (जीडीएल) एल्गोरिदम

इनपुट: स्थानीय प्रांत का समुच्चय।
आउटपुट: प्रांत के दिए गए समुच्चय के लिए, समस्या को हल करने के लिए आवश्यक न्यूनतम संख्या में संक्रिया की गणना की जाती है।
फिर यदि और संधि ट्री में किनारे से जुड़े होते हैं, फिर संदेश से को किसी फलन द्वारा दिए गए मानों का समुच्चय/तालिका है: :। सभी कार्यों के साथ आरंभ करने के लिए अर्थात सभी संयोजनों के लिए और दिए गए ट्री में, को समान रूप से में परिभाषित किया गया है और जब कोई विशेष संदेश अद्यतन किया जाता है, तो यह नीचे दिए गए समीकरण का पालन करता है।

=

जहां का अर्थ है कि ट्री में का आसन्न शीर्ष है।

इसी प्रकार प्रत्येक शीर्ष पर स्थिति होती है जिसे फलन के मानों वाली तालिका के रूप में परिभाषित किया जाता है , निश्चित वैसे ही जैसे संदेश 1 से प्रारंभ होते हैं, ठीक उसी प्रकार, की स्थिति स्थानीय कर्नेल के रूप में परिभाषित किया गया है, परंतु जब भी अद्यतन हो जाता है, यह निम्नलिखित समीकरण का पालन करता है:

एल्गोरिदम का मूल कार्य

अतः इनपुट के रूप में स्थानीय प्रांत के दिए गए समुच्चय के लिए, हम यह ज्ञात करते हैं कि क्या हम संधि ट्री बना सकते हैं, या तो प्रत्यक्षतः समुच्चय का उपयोग करके या पहले समुच्चय में प्रतिरूप प्रांत जोड़कर और फिर संधि ट्री बनाकर, यदि निर्माण संधि संभव नहीं है तो एल्गोरिदम आउटपुट देता है कि दिए गए समीकरण समस्या की गणना करने के लिए चरणों की संख्या को कम करने की कोई विधि नहीं है, परंतु बार जब हमारे निकट संधि ट्री होता है, तो एल्गोरिदम को संदेशों को नियोजित करना होगा और स्थितियों की गणना करनी होगी, ऐसा करने से हम जान सकते हैं कि चरणों को कहां कम किया जा सकता है, इसलिए इस पर नीचे चर्चा की जाएगी।

संदेश भेजने का नियोजन और स्थिति की गणना

ऐसी दो विशेष स्थिति हैं जिनके विषय में हम यहां बात करने जा रहे हैं, अर्थात् एकल शीर्ष समस्या जिसमें उद्देश्य फलन की गणना मात्र शीर्ष पर की जाती है। इस प्रकार से और दूसरा सभी शीर्ष समस्याएँ है जहां लक्ष्य सभी शीर्षों पर उदेश्य फलन की गणना करना है।

आइए 'एकल-शीर्ष समस्या' से प्रारंभ करें, जीडीएल प्रत्येक किनारे को लक्षित शीर्ष की ओर निर्देशित करके प्रारंभ करेगा। यहां संदेश मात्र लक्षित शीर्ष की दिशा में ही भेजे जाते हैं। ध्यान दें कि सभी निर्देशित संदेश मात्र एक बार भेजे जाते हैं। संदेश लीफ नोड्स (जहां डिग्री 1 है) से प्रारंभ होकर लक्ष्य शीर्ष की ओर बढ़ते हैं। संदेश पत्तियों से उसके माता-पिता तक और फिर वहां से उनके माता-पिता तक और इसी प्रकार तब तक चलता रहता है जब तक कि वह लक्ष्य शीर्ष तक नहीं पहुंच जाता है। लक्ष्य शिखर अपनी स्थिति की गणना तभी करेगा जब उसे अपने सभी निकटवर्तियों से सभी संदेश प्राप्त होंगे। एक बार जब हमें स्थिति मिल जाती है, तो हमें उत्तर मिल जाता है और इसलिए एल्गोरिदम समाप्त हो जाता है।

इस प्रकार से उदाहरण के लिए, आइए ऊपर दिए गए स्थानीय प्रांत के समुच्चय से निर्मित संधि ट्री पर विचार करें, अर्थात उदाहरण 1 से समुच्चय,
अब इन प्रांत के लिए शेड्यूलिंग तालिका है (जहां लक्ष्य शीर्ष है)।










इस प्रकार एकल शीर्ष जीडीएल की जटिलता को इस प्रकार दिखाया जा सकता है-

अंकगणितीय संक्रियाएँ
जहां (नोट: उपरोक्त समीकरण का स्पष्टीकरण लेख में बाद में बताया गया है)
का लेबल है।
की डिग्री (ग्राफ सिद्धांत) है (अर्थात् v के निकटवर्ती शीर्षों की संख्या)।

सभी शीर्ष समस्या को हल करने के लिए, हम जीडीएल को कई विधियों से नियोजक कर सकते हैं, उनमें से कुछ समानांतर कार्यान्वयन हैं जहां प्रत्येक समय में, प्रत्येक स्थिति को अपडेट किया जाता है और प्रत्येक संदेश की गणना और ही समय में प्रसारित किया जाता है। इस प्रकार के कार्यान्वयन में स्थिति और संदेश अधिक से अधिक संख्या में चक्कर लगाने के बाद स्थिर हो जाएंगे जो कि ट्री के व्यास के बराबर है। इस बिंदु पर शीर्षों की सभी अवस्थाएँ वांछित उद्देश्य फलन के बराबर होंगी।

इस समस्या के लिए जीडीएल को नियोजक करने की दूसरी विधि क्रमिक कार्यान्वयन है, जहां यह एकल शीर्ष समस्या के समान है, इसके अतिरिक्त कि हम एल्गोरिदम को तब तक नहीं रोकते हैं जब तक कि आवश्यक समुच्चय के सभी शीर्षों को अपने सभी निकटवर्तियों से सभी संदेश न मिल जाएं और उनकी स्थिति की गणना न कर लें।
इस प्रकार से इस कार्यान्वयन के लिए आवश्यक अंकगणित की संख्या अधिकतम अंकगणितीय संक्रिया है।

संधि ट्री का निर्माण

संधि ट्री बनाने की कुंजी स्थानीय प्रांत ग्राफ़ में निहित है, जो कि शीर्षों के साथ एक भारित पूर्ण ग्राफ़ है, अर्थात प्रत्येक स्थानीय प्रांत के लिए एक, जिसमें किनारे का भार द्वारा परिभाषित है।
यदि , तो हम कहते हैं जोकि में निहित है। द्वारा चिह्नित (अधिकतम भार वाले फैले हुए ट्री का भार ), जिसे

परिभाषित किया गया है, जहाँ n उस समुच्चय में अवयवों की संख्या है। अधिक स्पष्टता और विवरण के लिए, कृपया इन्हें देखें।[3][4]

शेड्यूलिंग प्रमेय

मान लीजिए कि शीर्ष समुच्चय और किनारा समुच्चय के साथ संधि ट्री बनें। इस एल्गोरिदम में, संदेश किसी भी किनारे पर दोनों दिशाओं में भेजे जाते हैं, इसलिए हम किनारे के समुच्चय E को शीर्षों के क्रमित जोड़े के समुच्चय के रूप में कह/मान सकते हैं। इस प्रकार से उदाहरण के लिए, चित्र 1 से निम्नानुसार परिभाषित किया जा सकता है-

टिप्पणी: उपरोक्त आपको वे सभी संभावित दिशा-निर्देश देता है जिनसे संदेश ट्री में यात्रा सकता है।

अतः जीडीएल के लिए नियोजक को उपसमुच्चय के सीमित अनुक्रम के रूप में परिभाषित किया गया है। जिसका सामान्यतः प्रतिनिधित्व किया जाता है

{}, जहां के समयान अद्यतन किए गए संदेशों एल्गोरिदम चलाने के समय का समुच्चय है।

इस प्रकार से कुछ अंकनों को परिभाषित/देखने के बाद, हम देखेंगे कि प्रमेय कहता है, जब हमें एक नियोजक दिया जाता है, के शीर्ष समुच्चय के साथ परिमित निर्देशित ग्राफ के रूप में संबंधित जालक (ग्राफ) है, जिसमें विशिष्ट अवयव के लिए को निरूपित किया जाता है, फिर संदेश पारित होने के पूर्ण होने के बाद, शीर्ष पर स्थिति

में परिभाषित उद्देश्य होगी और यदि से तक कोई पथ है।

कम्प्यूटेशनल जटिलता

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

उदाहरण: सबसे सरल स्थिति पर विचार करें जहां हमें निम्नलिखित अभिव्यक्ति की गणना करने की आवश्यकता है।

अतः इस अभिव्यक्ति का मूल्यांकन करने के लिए दो गुणा और योग की आवश्यकता होती है। अभिव्यक्ति जब वितरणात्मक नियम का उपयोग करके व्यक्त की जाती है तो उसे इस प्रकार लिखा जा सकता है, सरल अनुकूलन जो संचालन की संख्या को योग और गुणा तक कम कर देता है।

इस प्रकार से ऊपर बताए गए उदाहरण के समान हम जीडीएल लागू करके यथासंभव कम संक्रिया करने के लिए समीकरणों को विभिन्न रूपों में व्यक्त करेंगे।

जैसा कि पूर्व अनुभागों में बताया गया है, हम संधि ट्री की अवधारणा का उपयोग करके समस्या का हल करते हैं। इन ट्री के उपयोग से प्राप्त अनुकूलन ट्री पर अर्ध समूह समस्या को हल करके प्राप्त अनुकूलन के बराबर है। इस प्रकार से उदाहरण के लिए, संख्याओं के समूह का न्यूनतम ज्ञात करने के लिए हम यह देख सकते हैं कि यदि हमारे निकट ट्री है और सभी अवयव ट्री के नीचे हैं, तो हम समानांतर में दो वस्तुओं के न्यूनतम की तुलना कर सकते हैं और परिणामी न्यूनतम होगा माता-पिता को लिखा गया। जब यह प्रक्रिया ट्री तक फैलती है तो जड़ में अवयवों का न्यूनतम समूह पाया जाएगा।

संदेश पासिंग का उपयोग करके संधि ट्री को हल करने की जटिलता निम्नलिखित है-

हम पहले उपयोग किए गए सूत्र को निम्नलिखित रूप में फिर से लिखते हैं। यह शीर्ष v से w

तक भेजे जाने वाले संदेश का समीकरण है, ----संदेश समीकरण

इसी प्रकार हम शीर्ष v की स्थिति की गणना के लिए समीकरण को

के अनुसार फिर से लिखते हैं।

हम पहले एकल-शीर्ष समस्या का विश्लेषण करेंगे और मान लेंगे कि लक्ष्य शीर्ष है और इसलिए हमारे निकट से किनारा है।

इस प्रकार से मान लीजिए हमारे निकट बढ़त है, हम संदेश समीकरण का उपयोग करके संदेश की गणना करते हैं। की गणना करने के लिए

परिवर्धन और

गुणन की आवश्यकता होती है।

(हम को के रूप में दर्शाते हैं।)

परंतु के लिए कई संभावनाएं होंगी इसलिए

के लिए संभावनाएं हैं।

इस प्रकार पूर्ण संदेश को

परिवर्धन और

गुणन की आवश्यकता होगी।

ट्री के किनारों के साथ की ओर एक संदेश भेजने के लिए आवश्यक अंकगणितीय संक्रियाओं की कुल संख्या

जोड़ और

गुणन होगी।

एक बार जब सभी संदेश प्रसारित हो जाते हैं तो एल्गोरिदम स्थिति की गणना के साथ समाप्त हो जाता है, स्थिति गणना की अधिक गुणन आवश्यकता है।

इस प्रकार स्थिति की गणना के लिए आवश्यक गणनाओं की संख्या नीचे

जोड़ और

गुणन के रूप में दी गई है।

इस प्रकार गणनाओं की संख्या का कुल योग

----

है जहां एक किनारा है और इसका आकार द्वारा परिभाषित किया गया है।

उपरोक्त सूत्र हमें ऊपरी सीमा देता है।

यदि हम किनारे की जटिलता को परिभाषित करते हैं जैसा कि

है, इसलिए, को

के रूप में लिखा जा सकता है।

अतः अब हम चित्र 1 में परिभाषित समस्या के लिए किनारे की जटिलता की गणना

के अनुसार करते हैं।

इस प्रकार से कुल जटिलता होगी जो प्रत्यक्ष विधि की तुलना में अत्यधिक कम है। (यहां प्रत्यक्ष विधि से हमारा तात्पर्य उन विधियों से है जो संदेश भेजने का उपयोग नहीं करते हैं। प्रत्यक्ष विधि का उपयोग करने में लगने वाला समय प्रत्येक नोड पर संदेश की गणना करने और प्रत्येक नोड की स्थिति की गणना करने के समय के बराबर होगा।)

अतः अब हम कुल-शीर्ष समस्या पर विचार करते हैं जहां संदेश को दोनों दिशाओं में भेजना होगा और दोनों शीर्षों पर स्थिति की गणना करनी होगी। ये लगेगा, परंतु पूर्व कंप्यूटिंग द्वारा हम गुणन की संख्या को कम कर सकते हैं। यहाँ शीर्ष की घात है। उदाहरणार्थ: यदि कोई संख्याओं के साथ समुच्चय है। स्पष्ट के अतिरिक्त अधिकतम गुणन के साथ के के सभी d उत्पादों की गणना करना संभव है।

हम यह मात्रा

और की पूर्व-गणना करके ऐसा करते हैं, इसमें गुणन होता है। फिर यदि , को छोड़कर सभी के गुणनफल को दर्शाता है तो हमारे निकट है, और इसी प्रकार कुल बनाने के लिए अन्य गुणन की आवश्यकता होगी।

जब संधि ट्री के निर्माण की बात आती है तो हम बहुत कुछ नहीं कर सकते हैं, अतिरिक्त इसके कि हमारे निकट कई अधिकतम भार वाले स्पैनिंग ट्री हो सकते हैं और हमें सबसे कम भार वाले विस्तरित ट्री का चयन करना चाहिए। और कभी-कभी इसका तात्पर्य संधि ट्री जटिलता को कम करने के लिए स्थानीय प्रांत जोड़ना हो सकता है।

अतः ऐसा लग सकता है कि GDL तभी उचित है जब स्थानीय प्रांत को संधि ट्री के रूप में व्यक्त किया जा सकता है। परंतु ऐसी स्थितियोन में भी जहां चक्र और कई पुनरावृत्तियां हैं, संदेश लगभग उद्देश्य फलन के बराबर होंगे। कम घनत्व समता-जांच कोड के लिए गैलेजर-टान्नर-वाइबर्ग एल्गोरिदम पर प्रयोग इस अनुरोध का समर्थन करते थे।

संदर्भ

  1. 1.0 1.1 1.2 Aji, S.M.; McEliece, R.J. (Mar 2000). "सामान्यीकृत वितरणात्मक कानून" (PDF). IEEE Transactions on Information Theory. 46 (2): 325–343. doi:10.1109/18.825794.
  2. "वितरणात्मक कानून". Encyclopædia Britannica. Encyclopædia Britannica Online. Encyclopædia Britannica Inc. Retrieved 1 May 2012.
  3. "संग्रहीत प्रति" (PDF). Archived from the original (PDF) on 2015-03-19. Retrieved 2015-03-19. The Junction Tree Algorithms
  4. http://www-anw.cs.umass.edu/~cs691t/SS02/lectures/week7.PDF Archived 2012-05-26 at the Wayback Machine The Junction Tree Algorithm