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

For other uses, see Anamorphosis (disambiguation).

Not to be confused with Catamorphism.

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

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

एनामॉर्फिज्म का श्रेणीबद्ध द्वैत (उर्फ विपरीत) कैटामोर्फिज्म है।

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

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

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

उदाहरण: संभावित रूप से अनंत सूचियाँ

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

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

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

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].

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

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

उदाहरण के लिए, ट्री डेटा संरचना के लिए खुलासा

 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 सूचियों की एक जोड़ी लेता है, मान लीजिए ['ए','बी','सी'] और [1,2,3] और जोड़ियों की एक सूची लौटाता है [('ए',1),('बी',2),('सी',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 ये केवल परिभाषित शब्द हैं, जैसा कि हमने ऊपर दी गई परिभाषाओं से देखा है।

श्रेणी सिद्धांत में एनामोर्फिज्म

श्रेणी सिद्धांत में, एनामॉर्फिज्म, कैटामोर्फिज्म का श्रेणीबद्ध द्वैत है (और कैटामोर्फिज्म, एनामॉर्फिज्म का श्रेणीबद्ध द्वैत है)।

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

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

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

संकेतन

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

यह भी देखें

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

बाहरी संबंध

• Anamorphisms in Haskell