एनामोर्फिज्म

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से परिवर्तन कर दिया जाता है।

इतिहास

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

अनुप्रयोग

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 दिए गए हैं:

• $h=\mathrm {ana} \ f$
• $\mathrm {fin} \circ h=Fh\circ f$

नोटेशन

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

यह भी देखें

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

बाहरी संबंध

• Anamorphisms in Haskell