एनामोर्फिज्म: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
 
(6 intermediate revisions by 3 users not shown)
Line 2: Line 2:
{{confuse|कैटामोर्फिज्म}}
{{confuse|कैटामोर्फिज्म}}


कंप्यूटर प्रोग्रामिंग में,[[ आकारिता | एनामॉर्फिज्म]] फ़ंक्शन है जो की फ़ंक्शन को उसके पिछले परिणाम पर बार-बार प्रयुक्त करके अनुक्रम उत्पन्न करता है। आप कुछ मान A से प्रारंभ करते हैं और B प्राप्त करने के लिए उस पर फ़ंक्शन F प्रयुक्त करते हैं। फिर आप C प्राप्त करने के लिए B पर F प्रयुक्त करते हैं, और इसी प्रकार से जब तक कि कुछ समाप्ति की स्थिति नहीं आ जाती है। इस प्रकार से एनामॉर्फिज्म वह फ़ंक्शन है जो A, B, C आदि की सूची उत्पन्न करता है। अतः हम एनामॉर्फिज्म को प्रारंभिक मान के रूप में अनुक्रम प्रकट करने के लिए विचार कर सकते हैं।
कंप्यूटर प्रोग्रामिंग में,[[ आकारिता | '''एनामॉर्फिज्म''']] फ़ंक्शन है जो की फ़ंक्शन को उसके पिछले परिणाम पर पुनरावृत्त प्रयुक्त करके अनुक्रम उत्पन्न करता है। आप कुछ मान A से प्रारंभ करते हैं और B प्राप्त करने के लिए उस पर फ़ंक्शन F प्रयुक्त करते हैं। फिर आप C प्राप्त करने के लिए B पर F प्रयुक्त करते हैं, और इसी प्रकार से जब तक कि कुछ समाप्ति की स्थिति नहीं आ जाती है। इस प्रकार से एनामॉर्फिज्म वह फ़ंक्शन है जो A, B, C आदि की लिस्ट्स उत्पन्न करता है। अतः हम एनामॉर्फिज्म को प्रारंभिक मान के रूप में अनुक्रम प्रकट करने के लिए विचार कर सकते हैं।


'''उपरोक्त लाय्मंस'''  के विवरण को [[श्रेणी सिद्धांत]] में अधिक औपचारिक रूप से कहा जा सकता है: [[संयोग]] का एनामोर्फिज्म [[ एंडोफन्क्टर |एंडोफन्क्टर]] के [[प्रारंभिक बीजगणित]] के लिए अपने अद्वितीय रूपवाद के लिए [[कोलजेब्रा]] के असाइनमेंट को दर्शाता है। इन ऑब्जेक्ट्स का उपयोग [[कार्यात्मक प्रोग्रामिंग]] में ''फोल्ड (उच्च-क्रम फ़ंक्शन)'' के रूप में किया जाता है।
उपरोक्त लाय्मंस के विवरण को [[श्रेणी सिद्धांत|केटेगरी सिद्धांत]] में अधिक औपचारिक रूप से कहा जा सकता है: [[संयोग|कॉइनडक्टिव टाइप]] का एनामोर्फिज्म [[ एंडोफन्क्टर |एंडोफन्क्टर]] के [[प्रारंभिक बीजगणित|फाइनल कोलजेब्रा]] के लिए अपने अद्वितीय रूपवाद के लिए [[कोलजेब्रा]] के असाइनमेंट को दर्शाता है। इन ऑब्जेक्ट्स का उपयोग [[कार्यात्मक प्रोग्रामिंग|फ़ंक्शनल प्रोग्रामिंग]] में ''अनफोल्ड (उच्च-क्रम फ़ंक्शन)'' के रूप में किया जाता है।


एनामॉर्फिज्म का [[श्रेणीबद्ध द्वैत]] (उर्फ विपरीत) [[ कैटामोर्फिज्म |कैटामोर्फिज्म]] है।
एनामॉर्फिज्म का [[श्रेणीबद्ध द्वैत|केटेगोरिकल डुअल]] (अर्थात विपरीत) [[ कैटामोर्फिज्म |कैटामोर्फिज्म]] है।


== कार्यात्मक प्रोग्रामिंग में एनामॉर्फिज्म ==
== फ़ंक्शनल प्रोग्रामिंग में एनामॉर्फिज्म ==


कार्यात्मक प्रोग्रामिंग में, एनामॉर्फिज्म सहवर्ती [[सूची (कंप्यूटिंग)]] पर ''फोल्ड (उच्च-क्रम फ़ंक्शन)'' की अवधारणा का सामान्यीकरण है। औपचारिक रूप से, एनामॉर्फिज्म [[सामान्य कार्य]] हैं जो [[कोरकर्शन]] निश्चित [[बीजगणितीय डेटा प्रकार]] के परिणाम का निर्माण कर सकते हैं और जो कार्यों द्वारा पैरामीटरयुक्त होते हैं जो निर्माण के अगले एकल चरण को निर्धारित करते हैं।
इस प्रकार से फ़ंक्शनल प्रोग्रामिंग में, एनामॉर्फिज्म कॉइनडक्टिव [[सूची (कंप्यूटिंग)|लिस्ट्स (कंप्यूटिंग)]] पर अनफोल्ड ''(उच्च-क्रम फ़ंक्शन)'' की अवधारणा का सामान्यीकरण है। औपचारिक रूप से, एनामॉर्फिज्म [[सामान्य कार्य|जेनेरिक फंक्शनस]] हैं जो की [[कोरकर्शन]] निश्चित [[बीजगणितीय डेटा प्रकार|कोरकर्सिव]] के परिणाम का निर्माण कर सकते हैं और जो कार्यों द्वारा पैरामीटरयुक्त होते हैं जो निर्माण के अगले सिंगल स्टेप को निर्धारित करते हैं।


प्रश्न में डेटा प्रकार को सबसे बड़े निश्चित बिंदु ''ν X'' के रूप में परिभाषित किया गया है। फ़नकार ''एफ'' का एफ एक्स''। अंतिम कोलजेब्रा की सार्वभौमिक संपत्ति के अनुसार, अद्वितीय कोलजेब्रा रूपवाद ''ए → ν एक्स'' है। एफ एक्स'' किसी अन्य ''एफ''-कोलजेब्रा ''ए: ए → एफ ए'' के लिए। इस प्रकार, कोई व्यक्ति ''ए'' पर ''ए'' को कोलजेब्रा संरचना ''ए'' निर्दिष्ट करके सहवर्ती डेटाटाइप में ''ए'' से कार्यों को परिभाषित कर सकता है।
अतः प्रश्न में डेटा टाइप्स को अधिक उच्च निश्चित बिंदु ''ν X'' के रूप में परिभाषित किया गया है। यदि मान लीजिये फ़ैक्टर ''F'' का F X है''। तब अंतिम कोलजेब्रा की सार्वभौमिक गुण के अनुसार, यूनिक कोलजेब्रा मोरफिस्म'' A → ν X'' है।'' किसी अन्य F-कोलजेब्रा के लिए ''F X'': ''A → F A निर्धारित करते हैं।'' इस प्रकार, कोई A पर कोलजेब्रा स्ट्रक्चर A को निर्दिष्ट करके एक प्रकार A से एक कॉइनडक्टिव डेटाटाइप में कार्यों को परिभाषित कर सकता है।


=== उदाहरण: संभावित रूप से अनंत सूचियाँ ===
=== उदाहरण: पोटेंटियालय इनफिनिट लिस्ट्स ===


उदाहरण के तौर पर, संभावित अनंत सूची (कंप्यूटिंग) का प्रकार (एक निश्चित प्रकार के मान के तत्वों के साथ) निश्चित बिंदु [मूल्य] = ν X के रूप में दिया गया है। मान × ए (छद्म-)[[हास्केल (प्रोग्रामिंग भाषा)]]-परिभाषा इस तरह दिख सकती है:
इस प्रकार से उदाहरण के रूप में, पोटेंटियालय इनफिनिट लिस्ट्स (कंप्यूटिंग) का प्रकार (एक निश्चित प्रकार के मान के एलिमेंट के साथ) निश्चित बिंदु [मान ] = ν X के रूप में दिया गया है। मान ''× X + 1'' A (प्सयूडो-)[[हास्केल (प्रोग्रामिंग भाषा)|हास्केल (प्रोग्रामिंग लैंग्वेज )]]-परिभाषा इस तरह दर्शाया जा सकता है:


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
data [value] = (value:[value]) | []
data [value] = (value:[value]) | []
</syntaxhighlight>
</syntaxhighlight>
यह फ़नकार का निश्चित बिंदु है <code>F value</code>, कहाँ:
यह फ़ैक्टर <code>F value</code>, का निश्चित बिंदु है जहाँ:  


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
Line 27: Line 27:
data F value x = Maybe (value, x)
data F value x = Maybe (value, x)
</syntaxhighlight>
</syntaxhighlight>
कोई भी आसानी से जाँच सकता है कि वास्तव में यह प्रकार है <code>[value]</code> के लिए समरूपी है <code>F value [value]</code>, और इस तरह <code>[value]</code> निश्चित बिंदु है.
इस प्रकार से सरलता से जाँच कर सकते है कि वास्तव में यह प्रकार<code>[value]</code> है के <code>F value [value]</code> लिए समरूपी है , और इस तरह <code>[value]</code> निश्चित बिंदु है.
(यह भी ध्यान दें कि हास्केल में, फ़ैक्टर्स के न्यूनतम और सबसे बड़े निश्चित बिंदु मेल खाते हैं, इसलिए आगमनात्मक सूचियाँ संयोगात्मक, संभावित अनंत सूचियों के समान हैं।)


सूचियों के लिए एनामॉर्फिज्म (तब आमतौर पर अनफोल्ड के रूप में जाना जाता था) राज्य मूल्य से (संभावित अनंत) सूची का निर्माण करेगा। आमतौर पर, अनफ़ोल्ड राज्य मान लेता है <code>x</code> और समारोह <code>f</code> इससे या तो मूल्य का जोड़ा और नई स्थिति मिलती है, या सूची के अंत को चिह्नित करने के लिए सिंगलटन मिलता है। फिर एनामॉर्फिज्म पहले बीज के साथ प्रारंभ  होगा, गणना करेगा कि सूची जारी रहेगी या समाप्त होगी, और गैर-रिक्त सूची के मामले में, एनामॉर्फिज्म के लिए पुनरावर्ती कॉल के लिए गणना किए गए मान को जोड़ देगा।
(यह भी ध्यान दें कि हास्केल में, फ़ैक्टर्स के न्यूनतम और सबसे बड़े निश्चित बिंदु मेल खाते हैं, इसलिए आगमनात्मक लिस्ट्स संयोगात्मक, पोटेंटियालय इनफिनिट लिस्ट्स के समान हैं।)


सूचियों के लिए अनफ़ोल्ड या एनामॉर्फिज्म की हास्केल परिभाषा को कहा जाता है <code>ana</code>, इस प्रकार है:
अतः लिस्ट्स के लिए एनामॉर्फिज्म (तब सामान्यतः अनफोल्ड के रूप में जाना जाता था) अवस्था मान से (पोटेंटियालय इनफिनिट) लिस्ट्स का निर्माण करेगा। सामान्यतः , अनफ़ोल्ड अवस्था मान <code>x</code>लेता है और फ़ंक्शन <code>f प्राप्त करते है</code> जो या तो मान की जोड़ी और एक स्थिति मिलती है, या लिस्ट्स के अंत को चिह्नित करने के लिए सिंगलटन उत्पन्न करता है। फिर एनामॉर्फिज्म पहले मध्य गणना के साथ प्रारंभ होता है, अर्थात लिस्ट्स प्रवाहित रहे या समाप्त हो, और नॉनएम्प्टी लिस्ट्स के स्तिथि में, एनामॉर्फिज्म के लिए रिकर्सिव कॉल के लिए गणना किए गए मान को जोड़ देता है।
 
अतः लिस्ट्स के लिए एनामॉर्फिज्म, जिसे <code>ana</code>, कहा जाता है, की हास्केल परिभाषा इस प्रकार है:


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
Line 40: Line 41:
             Just (value, stateNew) -> value : ana f stateNew
             Just (value, stateNew) -> value : ana f stateNew
</syntaxhighlight>
</syntaxhighlight>
अब हम एना का उपयोग करके काफी सामान्य कार्यों को प्रयुक्त कर सकते हैं, उदाहरण के लिए उलटी गिनती:
अब हम <code>ana</code> का उपयोग करके अधिक जेनेरिक फंक्शनस को प्रयुक्त कर सकते हैं, इस प्रकार से उदाहरण के लिए काउंटडाउन कर सकते हैं:
<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
f :: Int -> Maybe (Int, Int)
f :: Int -> Maybe (Int, Int)
Line 48: Line 49:
                   else Just (oneSmaller, oneSmaller)
                   else Just (oneSmaller, oneSmaller)
</syntaxhighlight>
</syntaxhighlight>
यह फ़ंक्शन पूर्णांक को घटाएगा और इसे उसी समय आउटपुट करेगा, जब तक कि यह नकारात्मक न हो, जिस बिंदु पर यह सूची के अंत को चिह्नित करेगा। तदनुसार, <code>ana f 3</code> सूची की गणना करेगा <code>[2,1,0]</code>.
यह फ़ंक्शन पूर्णांक को घटाएगा और इसे उसी समय आउटपुट करते है, जब तक कि यह ऋणात्मक न हो, और जिस बिंदु पर यह लिस्ट्स के अंत को चिह्नित करते है। तदनुसार, <code>ana f 3</code> लिस्ट्स <code>[2,1,0]</code>की गणना करते है।


=== अन्य डेटा संरचनाओं पर एनामॉर्फिज्म ===
=== अन्य डेटा स्ट्रक्चर पर एनामॉर्फिज्म ===


एनामॉर्फिज्म को किसी भी पुनरावर्ती प्रकार के लिए परिभाषित किया जा सकता है, सामान्य पैटर्न के अनुसार, सूचियों के लिए एना के दूसरे संस्करण को सामान्यीकृत किया जा सकता है।
एनामॉर्फिज्म को किसी भी रिकर्सिव टाइप के लिए परिभाषित किया जा सकता है, जेनेरिक पैटर्न के अनुसार, लिस्ट्स के लिए <code>ana</code> के सेकंड वर्शन को जेनेरिक किया जा सकता है।


उदाहरण के लिए, ट्री डेटा संरचना के लिए खुलासा
उदाहरण के लिए, <code>Tree</code> डेटा स्ट्रक्चर के लिए अनफोल्ड करते है।


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
Line 66: Line 67:
                   Right (l, x, r) -> Branch (ana unspool l) x (ana unspool r)
                   Right (l, x, r) -> Branch (ana unspool l) x (ana unspool r)
</syntaxhighlight>
</syntaxhighlight>
पुनरावर्ती प्रकार और उसके एनामॉर्फिज़्म के बीच संबंध को बेहतर ढंग से देखने के लिए, उस पर ध्यान दें <code>Tree</code> और <code>List</code> इस प्रकार परिभाषित किया जा सकता है:
रिकर्सिव टाइप और उसके एनामॉर्फिज़्म के मध्य संबंध को उत्तम रूप से देखने के लिए, उस पर ध्यान दें कि<code>Tree</code> और <code>List</code> इस प्रकार परिभाषित किया जा सकता है:


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
Line 73: Line 74:
  newtype Tree a = Tree {unNode :: Either a (Tree a, a, Tree a))}
  newtype Tree a = Tree {unNode :: Either a (Tree a, a, Tree a))}
</syntaxhighlight>
</syntaxhighlight>
के साथ सादृश्य <code>ana</code> नाम बदलने से प्रकट होता है <code>b</code> इसके प्रकार में:
<code>ana</code> के साथ सादृश्य इसके प्रकार में<code>b</code>रिनेमिंग से प्रकट होता है:


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
Line 82: Line 83:
  anaTree ::      (tree_a      -> Either a (tree_a, a, tree_a)) -> (tree_a -> Tree a)
  anaTree ::      (tree_a      -> Either a (tree_a, a, tree_a)) -> (tree_a -> Tree a)
</syntaxhighlight>
</syntaxhighlight>
इन परिभाषाओं के साथ, प्रकार के कंस्ट्रक्टर के तर्क का प्रकार पहले तर्क के रिटर्न प्रकार के समान होता है <code>ana</code>, प्रकार के पुनरावर्ती उल्लेखों के साथ प्रतिस्थापित <code>b</code>.
इन परिभाषाओं के साथ, प्रकार के कंस्ट्रक्टर के लाॅजिक का प्रकार<code>ana</code>के पहले लाॅजिक के रिटर्न प्रकार के समान होता है , प्रकार के रिकर्सिव उल्लेखों को <code>b</code>से परिवर्तन कर दिया जाता है।


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


प्रोग्रामिंग के संदर्भ में एनामॉर्फिज्म की धारणा को पेश करने वाले पहले प्रकाशनों में से पेपर था केले, लेंस, लिफाफे और कांटेदार तार के साथ कार्यात्मक प्रोग्रामिंग,<ref>{{cite journal
इस प्रकार से प्रोग्रामिंग के संदर्भ में एनामॉर्फिज्म की धारणा को प्रस्तुत करने वाले पहले प्रकाशनों में से एक [[एरिक मीजर (कंप्यूटर वैज्ञानिक)|एरिक मीजर (कंप्यूटर वैज्ञानिक]] एट अल द्वारा लिखित केले, लेंस, पेपर और बार्बेड वायर के साथ फ़ंक्शनल प्रोग्रामिंग लैंग्वेज था, जो [[स्क्विगोल]] के संदर्भ में था।<ref>{{cite journal
|citeseerx = 10.1.1.41.125
|citeseerx = 10.1.1.41.125
|title=Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire
|title=Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire
Line 95: Line 96:
|year=1991
|year=1991
|pages=124–144
|pages=124–144
}}</ref> [[एरिक मीजर (कंप्यूटर वैज्ञानिक)]] एट अल द्वारा, जो [[स्क्विगोल]] प्रोग्रामिंग भाषा के संदर्भ में था।
}}</ref>


==अनुप्रयोग==
==अनुप्रयोग==
ज़िप (उच्च-क्रम फ़ंक्शन) जैसे कार्य|<code>zip</code>और <code>iterate</code> एनामॉर्फिज्म के उदाहरण हैं. <code>zip</code> सूचियों की जोड़ी लेता है, मान लीजिए ['ए','बी','सी'] और [1,2,3] और जोड़ियों की सूची लौटाता है [('ए',1),('बी',2),('सी',3)]। <code>Iterate</code> चीज़, x, और फ़ंक्शन, f, को ऐसी चीज़ों से ऐसी चीज़ों में लेता है, और अनंत सूची लौटाता है जो f के बार-बार अनुप्रयोग से आती है, यानी सूची [x, (f x), (f (f x)), (f (f (f x))), ...]।
<code>zip</code>और <code>iterate</code> जैसे फ़ंक्शन एनामॉर्फिज्म के उदाहरण हैं। <code>zip</code> लिस्ट्स की एक जोड़ी लेता है, मान लीजिए ['a','b','c'] और [1,2,3] और जोड़ियों की एक लिस्ट्स लौटाता है [('a',1),('b',2),('c',3)]। <code>Iterate</code> इस प्रकार से फ़ंक्शन तक एक अवस्था, x और एक फ़ंक्शन, f प्राप्त करता है, और इनफिनिट लिस्ट्स लौटाता है जो की f के पुनरावृत्त आवेदन से प्राप्त होती है, अर्थात लिस्ट्स [x, (f x), (f (f x)), (f (f (f x))), ...]।  


<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
Line 106: Line 107:
   
   
  iterate f x = x:(iterate f (f x))</syntaxhighlight>
  iterate f x = x:(iterate f (f x))</syntaxhighlight>
इसे साबित करने के लिए, हम अपने सामान्य अनफोल्ड का उपयोग करके दोनों को प्रयुक्त कर सकते हैं, <code>ana</code>, सरल पुनरावर्ती दिनचर्या का उपयोग करना:
इसे प्रमाणित करने के लिए, हम एक सामान्य रिकर्सिव रूटीन का उपयोग करके, अपने सामान्य अनफोल्ड, <code>ana</code>, का उपयोग करके दोनों को प्रयुक्त कर सकते हैं:
<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
  zip2 = ana unsp fin
  zip2 = ana unsp fin
Line 114: Line 115:


  iterate2 f = ana (\a->(a,f a)) (\x->False) </syntaxhighlight>
  iterate2 f = ana (\a->(a,f a)) (\x->False) </syntaxhighlight>
हास्केल जैसी भाषा में, अमूर्त भी कार्य करता है <code>fold</code>, <code>unfold</code> और <code>ana</code> ये केवल परिभाषित शब्द हैं, जैसा कि हमने ऊपर दी गई परिभाषाओं से देखा है।
अतः हास्केल जैसी लैंग्वेज में, अमूर्त फ़ंक्शंस <code>fold</code>, <code>unfold</code> और <code>ana</code> भी केवल परिभाषित शब्द हैं, जैसा कि हमने ऊपर दी गई परिभाषाओं से देखा है।
 
== केटेगरी सिद्धांत में एनामोर्फिज्म ==


== श्रेणी सिद्धांत में एनामोर्फिज्म ==
इस प्रकार से केटेगरी सिद्धांत में, एनामॉर्फिज्म, कैटामोर्फिज्म का केटेगोरिकल डुअल है (और कैटामोर्फिज्म, एनामॉर्फिज्म का केटेगोरिकल डुअल है)।


श्रेणी सिद्धांत में, एनामॉर्फिज्म, कैटामोर्फिज्म का श्रेणीबद्ध द्वैत है (और कैटामोर्फिज्म, एनामॉर्फिज्म का श्रेणीबद्ध द्वैत है)।
इसका अर्थ निम्नलिखित है मान लीजिए (A, ''fin'') अपने आप में कुछ [[श्रेणी (गणित)]] के कुछ एंडोफंक्टर F के लिए प्रारंभिक फाइनल F-कोलजेब्रा है।


इसका मतलब निम्नलिखित है.
इस प्रकार, ''fin'' A से ''FA'' तक रूपवाद है, और चूंकि इसे अंतिम माना जाता है, हम जानते हैं कि जब भी (''X'', ''f'') और F-कोलजेब्रा (X से ''FX'' तक रूपवाद ''f'' ) है, तो (''X'', ''f'') से (A, फिन) तक अद्वितीय [[समरूपता]] h होगा, जो X से h तक रूपवाद ''h'' है जैसे कि ''fin'' ''h = Fh '''.''' f''. फिर ऐसे प्रत्येक f के लिए हम 'एना' 'f' द्वारा निरूपित करते हैं जो विशिष्ट रूप से निर्दिष्ट रूपवाद h है।
मान लीजिए (ए, फिन) अपने आप में कुछ [[श्रेणी (गणित)]] के कुछ एंडोफंक्टर एफ के लिए प्रारंभिक बीजगणित एफ-कोलजेब्रा | एफ-कोलजेब्रा है।
इस प्रकार, फिन ए से एफए तक रूपवाद है, और चूंकि इसे अंतिम माना जाता है, हम जानते हैं कि जब भी (एक्स, एफ) और एफ-कोलजेब्रा (एक्स से एफएक्स तक रूपवाद एफ) है, तो (एक्स, एफ) से (ए, फिन) तक अद्वितीय [[समरूपता]] एच होगा, जो एक्स से ए तक रूपवाद एच है जैसे कि फिन '।' एच = एफएच '।' एफ।
फिर ऐसे प्रत्येक एफ के लिए हम 'एना' 'एफ' द्वारा निरूपित करते हैं जो विशिष्ट रूप से निर्दिष्ट रूपवाद एच है।


दूसरे शब्दों में, हमारे पास निम्नलिखित परिभाषित संबंध हैं, ऊपर दिए गए कुछ निश्चित एफ, ए और फिन दिए गए हैं:
अतः दूसरे शब्दों में, हमारे पास निम्नलिखित परिभाषित संबंध हैं, ऊपर दिए गए कुछ निश्चित ''F'', ''A'', और ''fin'' दिए गए हैं:


*<math>h = \mathrm{ana}\ f</math>
*<math>h = \mathrm{ana}\ f</math>
*<math>\mathrm{fin}\circ h = Fh \circ f</math>
*<math>\mathrm{fin}\circ h = Fh \circ f</math>


 
=== नोटेशन ===
=== संकेतन ===
अतः साहित्य में <code>ana</code> ''f'' के लिए <math>[\!(f)\!]</math> नोटेशन पाया गया है । इस प्रकार से उपयोग किए गए ब्रैकेट को लेंस ब्रैकेट के रूप में जाना जाता है, जिसके पश्चात एनामॉर्फिज्म को कभी-कभी लेंस के रूप में जाना जाता है।
के लिए संकेतन और यदि साहित्य में पाया जाता है <math>[\!(f)\!]</math>. उपयोग किए गए ब्रैकेट को लेंस ब्रैकेट के रूप में जाना जाता है, जिसके बाद एनामॉर्फिज्म को कभी-कभी ''लेंस'' कहा जाता है।


== यह भी देखें ==
== यह भी देखें ==
* रूपवाद
* मोरफिस्म्स
* [[एफ-बीजगणित]] की आकृतियाँ|एफ-बीजगणित
* [[एफ-बीजगणित|एफ-अलजेब्रा]] की मोरफिस्म्स
** प्रारंभिक बीजगणित से बीजगणित तक: कैटामोर्फिज्म
** प्रारंभिक अलजेब्रा से अलजेब्रा तक: कैटामोर्फिज्म
** एक एनामॉर्फिज्म जिसके बाद कैटामॉर्फिज्म आता है: हाइलोमोर्फिज्म (कंप्यूटर विज्ञान)
** एक एनामॉर्फिज्म जिसके पश्चात कैटामॉर्फिज्म आता है: हाइलोमोर्फिज्म (कंप्यूटर साइंस)
** कैटामोर्फिज्म के विचार का विस्तार: [[परारूपवाद]]
** कैटामोर्फिज्म के विचार का एक्सटेंशन: [[परारूपवाद|पैरामोर्फिज्म]]
** एनामोर्फिज्म के विचार का विस्तार: [[अपोमोर्फिज्म]]
** एनामोर्फिज्म के विचार का एक्सटेंशन: [[अपोमोर्फिज्म]]


== संदर्भ ==
== संदर्भ ==
{{reflist}}
{{reflist}}
== बाहरी संबंध ==
== बाहरी संबंध ==
* [http://ulissesaraujo.wordpress.com/2009/04/08/anamorphisms-in-haskell/ Anamorphisms in Haskell]
* [http://ulissesaraujo.wordpress.com/2009/04/08/anamorphisms-in-haskell/ Anamorphisms in Haskell]
[[Category: श्रेणी सिद्धांत]] [[Category: प्रत्यावर्तन योजनाएँ]]


[[Category: Machine Translated Page]]
[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category:CS1 errors]]
[[Category:Created On 24/07/2023]]
[[Category:Created On 24/07/2023]]
[[Category:Machine Translated Page]]
[[Category:Pages with script errors]]
[[Category:Templates Vigyan Ready]]
[[Category:प्रत्यावर्तन योजनाएँ]]
[[Category:श्रेणी सिद्धांत]]

Latest revision as of 18:11, 21 August 2023

For other uses, see एनामॉर्फोसिस (असंबद्धता).
Not to be confused with कैटामोर्फिज्म.

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

उपरोक्त लाय्मंस के विवरण को केटेगरी सिद्धांत में अधिक औपचारिक रूप से कहा जा सकता है: कॉइनडक्टिव टाइप का एनामोर्फिज्म एंडोफन्क्टर के फाइनल कोलजेब्रा के लिए अपने अद्वितीय रूपवाद के लिए कोलजेब्रा के असाइनमेंट को दर्शाता है। इन ऑब्जेक्ट्स का उपयोग फ़ंक्शनल प्रोग्रामिंग में अनफोल्ड (उच्च-क्रम फ़ंक्शन) के रूप में किया जाता है।

एनामॉर्फिज्म का केटेगोरिकल डुअल (अर्थात विपरीत) कैटामोर्फिज्म है।

फ़ंक्शनल प्रोग्रामिंग में एनामॉर्फिज्म

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

अतः प्रश्न में डेटा टाइप्स को अधिक उच्च निश्चित बिंदु ν X के रूप में परिभाषित किया गया है। यदि मान लीजिये फ़ैक्टर F का F X है। तब अंतिम कोलजेब्रा की सार्वभौमिक गुण के अनुसार, यूनिक कोलजेब्रा मोरफिस्म A → ν X है। किसी अन्य F-कोलजेब्रा के लिए F X: A → F A निर्धारित करते हैं। इस प्रकार, कोई A पर कोलजेब्रा स्ट्रक्चर A को निर्दिष्ट करके एक प्रकार A से एक कॉइनडक्टिव डेटाटाइप में कार्यों को परिभाषित कर सकता है।

उदाहरण: पोटेंटियालय इनफिनिट लिस्ट्स

इस प्रकार से उदाहरण के रूप में, पोटेंटियालय इनफिनिट लिस्ट्स (कंप्यूटिंग) का प्रकार (एक निश्चित प्रकार के मान के एलिमेंट के साथ) निश्चित बिंदु [मान ] = ν X के रूप में दिया गया है। मान × X + 1 A (प्सयूडो-)हास्केल (प्रोग्रामिंग लैंग्वेज )-परिभाषा इस तरह दर्शाया जा सकता है: 

data [value] = (value:[value]) | []

यह फ़ैक्टर F value, का निश्चित बिंदु है जहाँ: 

data Maybe a = Just a | Nothing
data F value x = Maybe (value, x)

इस प्रकार से सरलता से जाँच कर सकते है कि वास्तव में यह प्रकार[value] है के F value [value] लिए समरूपी है , और इस तरह [value] निश्चित बिंदु है.

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

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

अतः लिस्ट्स के लिए एनामॉर्फिज्म, जिसे ana, कहा जाता है, की हास्केल परिभाषा इस प्रकार है: 

ana :: (state -> Maybe (value, state)) -> state -> [value]
ana f stateOld = case f stateOld of
            Nothing                -> []
            Just (value, stateNew) -> value : ana f stateNew

अब हम ana का उपयोग करके अधिक जेनेरिक फंक्शनस को प्रयुक्त कर सकते हैं, इस प्रकार से उदाहरण के लिए काउंटडाउन कर सकते हैं: 

f :: Int -> Maybe (Int, Int)
f current = let oneSmaller = current - 1
            in   if oneSmaller < 0
                   then Nothing
                   else Just (oneSmaller, oneSmaller)

यह फ़ंक्शन पूर्णांक को घटाएगा और इसे उसी समय आउटपुट करते है, जब तक कि यह ऋणात्मक न हो, और जिस बिंदु पर यह लिस्ट्स के अंत को चिह्नित करते है। तदनुसार, ana f 3 लिस्ट्स [2,1,0]की गणना करते है।

अन्य डेटा स्ट्रक्चर पर एनामॉर्फिज्म

एनामॉर्फिज्म को किसी भी रिकर्सिव टाइप के लिए परिभाषित किया जा सकता है, जेनेरिक पैटर्न के अनुसार, लिस्ट्स के लिए ana के सेकंड वर्शन को जेनेरिक किया जा सकता है।

उदाहरण के लिए, Tree डेटा स्ट्रक्चर के लिए अनफोल्ड करते है। 

 data Tree a = Leaf a | Branch (Tree a) a (Tree a)

इस प्रकार है 

 ana :: (b -> Either a (b, a, b)) -> b -> Tree a
 ana unspool x = case unspool x of
                   Left a          -> Leaf a
                   Right (l, x, r) -> Branch (ana unspool l) x (ana unspool r)

रिकर्सिव टाइप और उसके एनामॉर्फिज़्म के मध्य संबंध को उत्तम रूप से देखने के लिए, उस पर ध्यान दें किTree और List इस प्रकार परिभाषित किया जा सकता है: 

 newtype List a = List {unCons :: Maybe (a, List a)}

 newtype Tree a = Tree {unNode :: Either a (Tree a, a, Tree a))}

ana के साथ सादृश्य इसके प्रकार मेंbरिनेमिंग से प्रकट होता है: 

 newtype List a = List {unCons :: Maybe (a, List a)}
 anaList ::       (list_a       -> Maybe (a, list_a)) -> (list_a -> List a)

 newtype Tree a = Tree {unNode :: Either a (Tree a, a, Tree a))}
 anaTree ::       (tree_a       -> Either a (tree_a, a, tree_a)) -> (tree_a -> Tree a)

इन परिभाषाओं के साथ, प्रकार के कंस्ट्रक्टर के लाॅजिक का प्रकारanaके पहले लाॅजिक के रिटर्न प्रकार के समान होता है , प्रकार के रिकर्सिव उल्लेखों को bसे परिवर्तन कर दिया जाता है।

इतिहास

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

अनुप्रयोग

zipऔर iterate जैसे फ़ंक्शन एनामॉर्फिज्म के उदाहरण हैं। zip लिस्ट्स की एक जोड़ी लेता है, मान लीजिए ['a','b','c'] और [1,2,3] और जोड़ियों की एक लिस्ट्स लौटाता है [('a',1),('b',2),('c',3)]। Iterate इस प्रकार से फ़ंक्शन तक एक अवस्था, x और एक फ़ंक्शन, f प्राप्त करता है, और इनफिनिट लिस्ट्स लौटाता है जो की f के पुनरावृत्त आवेदन से प्राप्त होती है, अर्थात लिस्ट्स [x, (f x), (f (f x)), (f (f (f x))), ...]। 

 zip (a:as) (b:bs) = if (as==[]) || (bs ==[])   -- || means 'or'
                      then [(a,b)]
                      else (a,b):(zip as bs) 
 
 iterate f x = x:(iterate f (f x))

इसे प्रमाणित करने के लिए, हम एक सामान्य रिकर्सिव रूटीन का उपयोग करके, अपने सामान्य अनफोल्ड, ana, का उपयोग करके दोनों को प्रयुक्त कर सकते हैं: 

 zip2 = ana unsp fin
    where
    fin (as,bs) = (as==[]) || (bs ==[]) 
    unsp ((a:as), (b:bs)) = ((a,b),(as,bs))

 iterate2 f = ana (\a->(a,f a)) (\x->False)

अतः हास्केल जैसी लैंग्वेज में, अमूर्त फ़ंक्शंस fold, unfold और ana भी केवल परिभाषित शब्द हैं, जैसा कि हमने ऊपर दी गई परिभाषाओं से देखा है।

केटेगरी सिद्धांत में एनामोर्फिज्म

इस प्रकार से केटेगरी सिद्धांत में, एनामॉर्फिज्म, कैटामोर्फिज्म का केटेगोरिकल डुअल है (और कैटामोर्फिज्म, एनामॉर्फिज्म का केटेगोरिकल डुअल है)।

इसका अर्थ निम्नलिखित है मान लीजिए (A, fin) अपने आप में कुछ श्रेणी (गणित) के कुछ एंडोफंक्टर F के लिए प्रारंभिक फाइनल F-कोलजेब्रा है।

इस प्रकार, fin A से FA तक रूपवाद है, और चूंकि इसे अंतिम माना जाता है, हम जानते हैं कि जब भी (X, f) और F-कोलजेब्रा (X से FX तक रूपवाद f ) है, तो (X, f) से (A, फिन) तक अद्वितीय समरूपता h होगा, जो X से h तक रूपवाद h है जैसे कि fin h = Fh . f. फिर ऐसे प्रत्येक f के लिए हम 'एना' 'f' द्वारा निरूपित करते हैं जो विशिष्ट रूप से निर्दिष्ट रूपवाद h है।

अतः दूसरे शब्दों में, हमारे पास निम्नलिखित परिभाषित संबंध हैं, ऊपर दिए गए कुछ निश्चित F, A, और fin दिए गए हैं:

नोटेशन

अतः साहित्य में ana f के लिए नोटेशन पाया गया है । इस प्रकार से उपयोग किए गए ब्रैकेट को लेंस ब्रैकेट के रूप में जाना जाता है, जिसके पश्चात एनामॉर्फिज्म को कभी-कभी लेंस के रूप में जाना जाता है।

यह भी देखें

  • मोरफिस्म्स
  • एफ-अलजेब्रा की मोरफिस्म्स
    • प्रारंभिक अलजेब्रा से अलजेब्रा तक: कैटामोर्फिज्म
    • एक एनामॉर्फिज्म जिसके पश्चात कैटामॉर्फिज्म आता है: हाइलोमोर्फिज्म (कंप्यूटर साइंस)
    • कैटामोर्फिज्म के विचार का एक्सटेंशन: पैरामोर्फिज्म
    • एनामोर्फिज्म के विचार का एक्सटेंशन: अपोमोर्फिज्म

संदर्भ

  1. ↑ Meijer, Erik; Fokkinga, Maarten; Paterson, Ross (1991). "Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire": 124–144. CiteSeerX 10.1.1.41.125. {{cite journal}}: Cite journal requires |journal= (help)

बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=एनामोर्फिज्म&oldid=251311’