प्रोग्रामिंग के संदर्भ में "कोलजेब्रा" का क्या अर्थ है?

Question

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

Comments

क्या मैं एफपी में जेरेमी गिबन्स की उत्कृष्ट पुस्तक पैटर्न की सिफारिश कर सकता हूं: patterninfp.wordpress.com और उनके काफी समझदार पेपर "कैलकुलेटिंग फंक्शनल प्रोग्राम्स"? वे दोनों काफी कड़े अंदाज में (एक ब्लॉग पोस्ट की तुलना में) कोलजेब्रा को कवर करते हैं , लेकिन वे किसी ऐसे व्यक्ति के लिए काफी आत्म निहित हैं, जो हास्केल को थोड़ा जानता है।

— क्रिस्टोफर माइकिन्सकी

@ क्रिस्‍टोफरमिक्‍किंस्‍की, बहुत रोचक। धन्यवाद!

— लापताफैक्टर

Answer 1

अल्जेब्रास

मुझे लगता है कि शुरू करने के लिए जगह एक बीजगणित के विचार को समझना होगा । यह समूह, वलय, भित्तिचित्र इत्यादि जैसे बीजीय संरचनाओं का सामान्यीकरण है। ज्यादातर समय, इन चीजों को सेट के संदर्भ में पेश किया जाता है, लेकिन जब से हम दोस्तों के बीच हैं, मैं इसके बजाय हास्केल प्रकारों के बारे में बात करूंगा। (हालांकि मैं कुछ ग्रीक अक्षरों का उपयोग करते हुए विरोध नहीं कर सकता - वे सब कुछ कूलर लग रहे हैं!)

एक बीजगणित, तब, τकुछ कार्यों और पहचानों के साथ एक प्रकार है । ये कार्य विभिन्न प्रकार के तर्कों की संख्या लेते हैं τऔर उत्पादन करते हैं τ: अविवाहित, वे सभी की तरह दिखते हैं (τ, τ,…, τ) → τ। उनकी "पहचान" भी हो सकती है- τकुछ कार्यों के साथ उनका विशेष व्यवहार होता है।

इसका सबसे सरल उदाहरण मोनॉइड है। एक τफ़ंक्शन mappend ∷ (τ, τ) → τऔर पहचान के साथ एक मोनॉयड किसी भी प्रकार का होता है mzero ∷ τ। अन्य उदाहरणों में समूह जैसी चीजें शामिल हैं (जो कि एक अतिरिक्त invert ∷ τ → τकार्य को छोड़कर मोनॉयड की तरह हैं ), अंगूठियां, जाली और इतने पर।

सभी कार्य संचालित होते हैं, τलेकिन विभिन्न प्रकार के हो सकते हैं। हम इनको इस प्रकार लिख सकते हैं τⁿ → τ, जहाँ τⁿमानचित्रों का एक tuple हो n τ। इस तरह, यह पहचान के बारे में सोचने के लिए समझ में आता है कि सिर्फ खाली टपल τ⁰ → τकहाँ τ⁰है ()। इसलिए हम वास्तव में एक बीजगणित के विचार को सरल बना सकते हैं: यह केवल कुछ प्रकार के कार्यों के साथ है।

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

एफ अल्जेब्रास

हालांकि, हम फैक्टरिंग के साथ काफी नहीं हैं। अब तक, हमारे पास कार्यों का एक समूह है τⁿ → τ। हम वास्तव में उन सभी को एक फ़ंक्शन में संयोजित करने के लिए एक स्वच्छ चाल कर सकते हैं। विशेष रूप से, चलो monoids को देखें: हमारे पास mappend ∷ (τ, τ) → τऔर है mempty ∷ () → τ। हम एक राशि प्रकार का उपयोग करके इन्हें एकल फ़ंक्शन में बदल सकते हैं- Either। यह इस तरह दिखेगा:

op ∷ Monoid τ ⇒ Either (τ, τ) () → τ
op (Left (a, b)) = mappend (a, b)
op (Right ())    = mempty

हम वास्तव में गठबंधन करने के लिए बार-बार इस बदलाव का उपयोग कर सकते सबτⁿ → τ के लिए, एक भी एक में कार्यों किसी भी बीजगणित। (वास्तव में, हम कार्यों के किसी भी संख्या के लिए ऐसा कर सकते हैं a → τ, b → τऔर इतने के लिए पर किसी भी a, b,… ।)

यह हमें एक प्रकार के रूप अल्जेब्रास के बारे में बात करने देता है τएक साथ एक समारोह के कुछ गड़बड़ से Eitherरों एक भी करने के लिए τ। मोनोइड्स के लिए, यह गड़बड़ है Either (τ, τ) ():; समूहों के लिए (जिनके पास अतिरिक्त τ → τऑपरेशन है), यह है Either (Either (τ, τ) τ) ():। यह हर अलग संरचना के लिए एक अलग प्रकार है। तो इन सभी प्रकारों में क्या आम है? सबसे स्पष्ट बात यह है कि वे सभी उत्पादों के बीज हैं - बीजीय डेटा प्रकार। उदाहरण के लिए, मोनोइड्स के लिए, हम एक मोनॉइड तर्क प्रकार बना सकते हैं जो किसी भी मोनोइड के लिए काम करता है oids:

data MonoidArgument τ = Mappend τ τ -- here τ τ is the same as (τ, τ)
                      | Mempty      -- here we can just leave the () out

हम समूहों और अंगूठियों और जाली और अन्य सभी संभावित संरचनाओं के लिए एक ही काम कर सकते हैं।

इन सभी प्रकारों के बारे में और क्या खास है? खैर, वे सब कर रहे हैं Functors! उदाहरण के लिए:

instance Functor MonoidArgument where
  fmap f (Mappend τ τ) = Mappend (f τ) (f τ)
  fmap f Mempty        = Mempty

इसलिए हम बीजगणित के अपने विचार को और भी सामान्य कर सकते हैं। यह केवल कुछ प्रकार τके f τ → τफंक्शनर के लिए एक फंक्शन है f। वास्तव में, हम इसे टाइपसेकल्स के रूप में लिख सकते हैं:

class Functor f ⇒ Algebra f τ where
  op ∷ f τ → τ

इसे अक्सर "एफ-बीजगणित" कहा जाता है क्योंकि यह फ़नकार द्वारा निर्धारित किया जाता है F। अगर हम आंशिक रूप से टाइपकास्ट लागू कर सकते हैं, तो हम कुछ को परिभाषित कर सकते हैं class Monoid = Algebra MonoidArgument।

Coalgebras

अब, उम्मीद है कि आपके पास एक बीजगणित क्या है और यह कैसे सामान्य बीजगणितीय संरचनाओं के सामान्यीकरण का एक अच्छा उदाहरण है। तो F-Coalgebra क्या है? ठीक है, सह का अर्थ है कि यह एक बीजगणित का "दोहरा" है - अर्थात्, हम एक बीजगणित लेते हैं और कुछ तीरों को फ्लिप करते हैं। मुझे उपरोक्त परिभाषा में केवल एक तीर दिखाई देता है, इसलिए मैं इसे केवल फ्लिप करूंगा:

class Functor f ⇒ CoAlgebra f τ where
  coop ∷ τ → f τ

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

वर्ग और वस्तुएँ

लगभग थोड़ा पढ़ने के बाद, मुझे लगता है कि मुझे कक्षाओं और वस्तुओं का प्रतिनिधित्व करने के लिए कोलजेब्रा का उपयोग करने का एक अच्छा विचार है। हमारे पास एक प्रकार Cहै जिसमें कक्षा में वस्तुओं के सभी संभव आंतरिक राज्य होते हैं; वर्ग अपने आप में एक कोलजेब्रा है, Cजो वस्तुओं के तरीकों और गुणों को निर्दिष्ट करता है।

जैसा कि बीजगणित के उदाहरण में दिखाया गया है, यदि हमारे पास कार्यों का एक गुच्छा है जैसे a → τऔर b → τकिसी के लिए a, b,…, हम उन सभी को एक एकल फ़ंक्शन का उपयोग करके जोड़ सकते हैं Either, एक राशि प्रकार। दोहरे "धारणा" प्रकार के कार्यों का एक गुच्छा संयोजन होगा τ → a, τ → bऔर इसी तरह। हम एक योग प्रकार के दोहरे उपयोग कर सकते हैं — एक उत्पाद प्रकार। तो ऊपर (बुलाया दो कार्यों को देखते हुए fऔर g), हम तो जैसे एक भी बना सकते हैं:

both ∷ τ → (a, b)
both x = (f x, g x)

प्रकार (a, a)सीधे रूप में एक मजेदार है, इसलिए यह निश्चित रूप से एक एफ-कोलजेब्रा की हमारी धारणा के साथ फिट बैठता है। यह विशेष ट्रिक हमें OOP के लिए अलग-अलग फंक्शंस के एक समूह को टाइप करने की सुविधा देती है τ → f τ।

हमारे प्रकार के तत्व वस्तु Cकी आंतरिक स्थिति का प्रतिनिधित्व करते हैं । यदि ऑब्जेक्ट में कुछ पठनीय गुण हैं, तो उन्हें राज्य पर निर्भर रहने में सक्षम होना चाहिए। ऐसा करने का सबसे स्पष्ट तरीका है कि उन्हें एक कार्य करना है C। इसलिए यदि हम एक लंबाई संपत्ति (जैसे object.length) चाहते हैं, तो हमारे पास एक फ़ंक्शन होगा C → Int।

हम ऐसे तरीके चाहते हैं जो एक तर्क ले सकें और राज्य को संशोधित कर सकें। ऐसा करने के लिए, हमें सभी तर्कों को लेने और एक नया निर्माण करने की आवश्यकता है C। आइए एक setPositionविधि की कल्पना करें जो एक xऔर एक yसमन्वय लेता है object.setPosition(1, 2):। यह इस तरह दिखेगा C → ((Int, Int) → C):।

यहां महत्वपूर्ण पैटर्न यह है कि ऑब्जेक्ट के "तरीके" और "गुण" ऑब्जेक्ट को अपने पहले तर्क के रूप में लेते हैं। यह selfपाइथन में पैरामीटर की तरह है और thisकई अन्य भाषाओं के निहितार्थ की तरह है । एक coalgebra अनिवार्य रूप से सिर्फ एक लेने के व्यवहार समाहित selfपैरामीटर: बात यह है कि पहले क्या Cमें C → F Cहै।

तो चलो यह सब एक साथ डाल दिया। आइए एक positionसंपत्ति, एक nameसंपत्ति और setPositionकार्य के साथ एक वर्ग की कल्पना करें :

class C
  private
    x, y  : Int
    _name : String
  public
    name        : String
    position    : (Int, Int)
    setPosition : (Int, Int) → C

इस वर्ग का प्रतिनिधित्व करने के लिए हमें दो भागों की आवश्यकता है। सबसे पहले, हमें ऑब्जेक्ट की आंतरिक स्थिति का प्रतिनिधित्व करने की आवश्यकता है; इस मामले में यह सिर्फ दो Intएस और एक रखती है String। (यह हमारा प्रकार है C।) फिर हमें कक्षा का प्रतिनिधित्व करने वाले कोलजेब्रा के साथ आने की आवश्यकता है।

data C = Obj { x, y  ∷ Int
             , _name ∷ String }

हमारे पास लिखने के दो गुण हैं। वे बहुत तुच्छ हैं:

position ∷ C → (Int, Int)
position self = (x self, y self)

name ∷ C → String
name self = _name self

अब हमें केवल स्थिति को अपडेट करने में सक्षम होना चाहिए:

setPosition ∷ C → (Int, Int) → C
setPosition self (newX, newY) = self { x = newX, y = newY }

यह अपने स्पष्ट selfचर के साथ पायथन वर्ग की तरह है । अब जब हमारे पास self →कार्यों का एक गुच्छा है , तो हमें उन्हें गठबंधन के लिए एकल फ़ंक्शन में संयोजित करने की आवश्यकता है। हम एक साधारण टपल के साथ यह कर सकते हैं:

coop ∷ C → ((Int, Int), String, (Int, Int) → C)
coop self = (position self, name self, setPosition self)

प्रकार ((Int, Int), String, (Int, Int) → c)- किसी भी c एक फनकार के लिए, इसलिए हमारे coopपास वह रूप है जो हम चाहते हैं Functor f ⇒ C → f C:।

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

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

संक्षेप में, एक एफ-कोलजेब्रा गुण और विधियों का एक समूह होने से एक वर्ग का प्रतिनिधित्व करता है जो सभी selfएक ऑब्जेक्ट के आंतरिक स्थिति वाले पैरामीटर पर निर्भर करते हैं ।

अन्य श्रेणियाँ

अब तक, हमने अल्जेब्रा और कोलजेब्रा के बारे में हास्केल प्रकारों के बारे में बात की है। एक बीजगणित τएक प्रकार्य के साथ एक प्रकार है f τ → τऔर एक बीजगणित एक प्रकार्य के τसाथ एक प्रकार है τ → f τ।

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

हम कुछ श्रेणी के लिए एक एफ-बीजगणित को परिभाषित कर सकते हैं C। सबसे पहले, हमें F : C → Cएक फ़नकार की आवश्यकता है -यह एक एंडोफ़नक्टर है । (सभी हास्केल Functorरों वास्तव में से endofunctors हैं Hask → Hask।) फिर, एक बीजगणित सिर्फ एक वस्तु है Aसे Cएक आकारिता साथ F A → A। एक कोलब्रेग एक ही है सिवाय इसके A → F A।

अन्य श्रेणियों पर विचार करके हम क्या हासिल करते हैं? खैर, हम अलग-अलग संदर्भों में समान विचारों का उपयोग कर सकते हैं। सन्यासी की तरह। हास्केल में, एक मोनड M ∷ ★ → ★तीन प्रकारों के साथ कुछ प्रकार है :

map      ∷ (α → β) → (M α → M β)
return   ∷ α → M α
join     ∷ M (M α) → M α

mapसमारोह सिर्फ तथ्य यह है कि का प्रमाण है Mहै एक Functor। तो हम कह सकते हैं कि एक सन्यासी सिर्फ दो कार्यों वाला एक फनकार है : returnऔर join।

फ़नकार स्वयं एक श्रेणी बनाते हैं, जिसमें आकारिकी के बीच तथाकथित "प्राकृतिक परिवर्तन" होते हैं। एक प्राकृतिक परिवर्तन अपनी संरचना को संरक्षित करते हुए एक फ़नकार को दूसरे में बदलने का एक तरीका है। यहाँ एक अच्छा लेख है जो विचार को समझाने में मदद करता है। यह बात करता है concat, जो सिर्फ joinसूचियों के लिए है।

हास्केल फंक्शनलर्स के साथ, दो फंक्शनलर्स की रचना स्वयं एक फ़नकार है। छद्मकोड में, हम इसे लिख सकते हैं:

instance (Functor f, Functor g) ⇒ Functor (f ∘ g) where
  fmap fun x = fmap (fmap fun) x

इससे हमें joinमैपिंग के बारे में सोचने में मदद मिलती है f ∘ f → f। का प्रकार joinहै ∀α. f (f α) → f α। सहज रूप से, हम देख सकते हैं कि किस प्रकार सभी प्रकार के लिए मान्य फ़ंक्शन αको परिवर्तन के रूप में माना जा सकता है f।

returnएक समान परिवर्तन है। इसके प्रकार है ∀α. α → f α। यह अलग दिखता है - पहला α"फनकार" नहीं है! सौभाग्य से, हम वहाँ एक पहचान functor जोड़कर इसे ठीक कर सकते हैं: ∀α. Identity α → f α। तो returnएक परिवर्तन है Identity → f।

अब हम एक संन्यासी के बारे में सोच सकते हैं जैसे कि fऑपरेशन के साथ कुछ फ़नकार के चारों ओर बस एक बीजगणित f ∘ f → fऔर Identity → f। क्या यह परिचित नहीं है? यह एक मोनॉइड के समान है, जो τऑपरेशन के साथ सिर्फ कुछ प्रकार का था τ × τ → τऔर () → τ।

तो एक सन्यासी सिर्फ एक भिक्षु की तरह होता है, सिवाय इसके कि हमारे पास एक फनकार है। यह एक ही श्रेणी में बीजगणित के समान है। (यह वह जगह है जहां वाक्यांश "एक भिक्षु एंडोफुन्क्टरों की श्रेणी में सिर्फ एक मठ है" जहां तक ​​आपको पता है।)

अब, हमारे पास ये दो ऑपरेशन हैं: f ∘ f → fऔर Identity → f। संबंधित कोलजेब्रा पाने के लिए, हम सिर्फ तीर को पलटाते हैं। यह हमें दो नए ऑपरेशन देता है: f → f ∘ fऔर f → Identity। हम उन्हें उपरोक्त प्रकार के चर जोड़कर हास्केल प्रकारों में बदल सकते हैं, हमें ∀α. f α → f (f α)और ∀α. f α → α। यह कॉमनोड की परिभाषा जैसा दिखता है:

class Functor f ⇒ Comonad f where
  coreturn ∷ f α → α
  cojoin   ∷ f α → f (f α)

तो एक comonad तो एक है coalgebra endofunctors की एक श्रेणी में।

Comments

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

— लुइस कैसिलस

यह एक महान व्याख्या है।

— एडवर्ड केमेट

@EdwardKmett: धन्यवाद। क्या सामान मैंने कक्षाओं और वस्तुओं के बारे में जोड़ा है ठीक है? मैं केवल आज इसके बारे में पढ़ता हूं, लेकिन यह समझ में आता है।

— तिखन जेल्विस

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

— सीए मैककैन

यह एक महाकाव्य अंत था!

— jdinunzio

Answer 2

एफ-अलजेब्रा और एफ-कोलजेब्रस गणितीय संरचनाएं हैं जो प्रेरक प्रकार (या पुनरावर्ती प्रकार ) के बारे में तर्क में सहायक हैं ।

एफ अल्जेब्रास

हम सबसे पहले F-algebras से शुरुआत करेंगे। मैं यथासंभव सरल होने की कोशिश करूंगा।

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

data IntList = Nil | Cons (Int, IntList)

यह स्पष्ट है कि यह पुनरावर्ती है - वास्तव में, इसकी परिभाषा स्वयं को संदर्भित करती है। इसकी परिभाषा में दो डेटा निर्माता हैं, जिनके निम्न प्रकार हैं:

Nil  :: () -> IntList
Cons :: (Int, IntList) -> IntList

ध्यान दें कि मैं के प्रकार लिखा है Nilके रूप में () -> IntList, बस नहीं IntList। ये वास्तव में सैद्धांतिक दृष्टिकोण से समकक्ष प्रकार हैं, क्योंकि ()प्रकार में केवल एक निवासी है।

यदि हम इन कार्यों के हस्ताक्षर अधिक सेट-थ्योरिटिकल तरीके से लिखते हैं, तो हम प्राप्त करेंगे

Nil  :: 1 -> IntList
Cons :: Int × IntList -> IntList

जहां 1एक इकाई सेट (एक तत्व के साथ सेट) और A × Bऑपरेशन दो सेटों का एक क्रॉस उत्पाद है ( Aऔर B, उन युग्मों का सेट (a, b)जहां aसभी तत्वों के माध्यम से जाता है Aऔर bसभी तत्वों के माध्यम से जाता है B)।

दो सेटों का मिलन समाप्त करें Aऔर Bएक सेट है A | Bजो सेटों का एक संघ है {(a, 1) : a in A}और {(b, 2) : b in B}। अनिवार्य रूप से यह दोनों Aऔर से सभी तत्वों का एक सेट है B, लेकिन इस तत्व में से प्रत्येक के साथ Aया तो संबंधित 'चिह्नित' है B, इसलिए जब हम किसी भी तत्व को चुनते हैं, तो A | Bहम तुरंत यह जान लेंगे कि यह तत्व आया था Aया उससे B।

हम 'जॉइन' कर सकते हैं Nilऔर Consकार्य कर सकते हैं , इसलिए वे एक सेट पर काम करने वाले एकल फंक्शन का निर्माण करेंगे 1 | (Int × IntList):

Nil|Cons :: 1 | (Int × IntList) -> IntList

वास्तव में, यदि Nil|Consफ़ंक्शन को ()मूल्य पर लागू किया जाता है (जो, जाहिर है, 1 | (Int × IntList)सेट करने के लिए है), तो यह व्यवहार करता है जैसे कि यह था Nil; यदि Nil|Consकिसी भी प्रकार के मूल्य पर लागू किया जाता है (Int, IntList)(ऐसे मूल्य सेट में भी हैं 1 | (Int × IntList), तो यह व्यवहार करता है Cons।

अब एक और डेटाटाइप पर विचार करें:

data IntTree = Leaf Int | Branch (IntTree, IntTree)

इसके निम्न निर्माता हैं:

Leaf   :: Int -> IntTree
Branch :: (IntTree, IntTree) -> IntTree

जो भी एक समारोह में शामिल हो सकते हैं:

Leaf|Branch :: Int | (IntTree × IntTree) -> IntTree

यह देखा जा सकता है कि इस joinedकार्य के दोनों प्रकार समान हैं: वे दोनों समान दिखते हैं

f :: F T -> T

जहाँ Fएक प्रकार का परिवर्तन होता है जो हमारे प्रकार को लेता है और अधिक जटिल प्रकार देता है, जिसमें xऔर |संचालन, उपयोग Tऔर संभवतः अन्य प्रकार होते हैं। उदाहरण के लिए, निम्नानुसार IntListऔर IntTree Fदिखता है:

F1 T = 1 | (Int × T)
F2 T = Int | (T × T)

हम तुरंत नोटिस कर सकते हैं कि किसी भी बीजीय प्रकार को इस तरह से लिखा जा सकता है। वास्तव में, इसीलिए उन्हें 'बीजगणितीय' कहा जाता है: वे कई प्रकार के 'सम्स' (यूनियनों) और 'उत्पादों' (क्रॉस उत्पादों) से मिलकर बनते हैं।

अब हम एफ-बीजगणित को परिभाषित कर सकते हैं। एफ-बीजगणित सिर्फ एक जोड़ी है (T, f), जहां Tकुछ प्रकार है और प्रकार fका एक कार्य है f :: F T -> T। हमारे उदाहरणों में F-algebras हैं (IntList, Nil|Cons)और (IntTree, Leaf|Branch)। ध्यान दें, हालांकि, इसके बावजूद कि fप्रत्येक एफ के लिए उस प्रकार का फ़ंक्शन समान है, Tऔर fस्वयं मनमाना हो सकता है। उदाहरण के लिए, (String, g :: 1 | (Int x String) -> String)या (Double, h :: Int | (Double, Double) -> Double)कुछ के लिए gऔर hइसी एफ के लिए एफ-अल्जेब्रा भी हैं।

बाद में हम एफ-बीजगणित समरूपता और फिर प्रारंभिक एफ-बीजगणित का परिचय दे सकते हैं , जिसमें बहुत उपयोगी गुण हैं। वास्तव में, (IntList, Nil|Cons)एक प्रारंभिक F1-बीजगणित है, और (IntTree, Leaf|Branch)एक प्रारंभिक F2-बीजगणित है। मैं इन शर्तों और गुणों की सटीक परिभाषा प्रस्तुत नहीं करूंगा क्योंकि वे जरूरत से ज्यादा जटिल और सार हैं।

बहरहाल, तथ्य यह है कि, कहते हैं, (IntList, Nil|Cons)एफ-बीजगणित हमें foldइस प्रकार पर परिभाषित -समान फ़ंक्शन की अनुमति देता है । जैसा कि आप जानते हैं, गुना एक प्रकार का ऑपरेशन है जो एक परिमित मूल्य में कुछ पुनरावर्ती डेटाटाइप को बदलता है। उदाहरण के लिए, हम पूर्णांक की एक सूची को एक एकल मान में बदल सकते हैं जो सूची में सभी तत्वों का योग है:

foldr (+) 0 [1, 2, 3, 4] -> 1 + 2 + 3 + 4 = 10

किसी भी पुनरावर्ती डेटाटाइप पर इस तरह के ऑपरेशन को सामान्य करना संभव है।

निम्नलिखित foldrसमारोह का एक हस्ताक्षर है :

foldr :: ((a -> b -> b), b) -> [a] -> b

ध्यान दें कि मैंने पहले दो तर्कों को पिछले एक से अलग करने के लिए ब्रेसिज़ का उपयोग किया है। यह वास्तविक foldrकार्य नहीं है, लेकिन यह इसके लिए आइसोमोर्फिक है (अर्थात, आप आसानी से दूसरे से एक और इसके विपरीत प्राप्त कर सकते हैं)। आंशिक रूप से लागू foldrनिम्नलिखित हस्ताक्षर होंगे:

foldr ((+), 0) :: [Int] -> Int

हम देख सकते हैं कि यह एक फ़ंक्शन है जो पूर्णांक की एक सूची लेता है और एक पूर्णांक देता है। आइए ऐसे फ़ंक्शन को हमारे IntListप्रकार के संदर्भ में परिभाषित करें।

sumFold :: IntList -> Int
sumFold Nil         = 0
sumFold (Cons x xs) = x + sumFold xs

हम देखते हैं कि इस फ़ंक्शन में दो भाग होते हैं: पहला भाग इस फ़ंक्शन के Nilभाग के व्यवहार को IntListपरिभाषित करता है, और दूसरा भाग कार्य के व्यवहार को परिभाषित करता है Cons।

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

reductor :: () | (Int × Int) -> Int
reductor ()     = 0
reductor (x, s) = x + s

यह देखा जा सकता है कि एफ-बीजगणित की परिभाषा के अनुसार, reductorफ़ंक्शन का एक प्रकार F1 Int -> Intहै! दरअसल, यह जोड़ी (Int, reductor)F1-बीजगणित है।

क्योंकि IntListएक प्रारंभिक एफ 1-बीजगणित है, प्रत्येक प्रकार के लिए Tऔर प्रत्येक फ़ंक्शन के लिए एक फ़ंक्शन r :: F1 T -> Tमौजूद है, जिसे कैटोर्फिज्म कहा जाता है r, जिसके लिए अभिसरण होता IntListहै T, और ऐसा फ़ंक्शन अद्वितीय होता है। वास्तव में, हमारे उदाहरण में इसके लिए एक कायापलट reductorहै sumFold। ध्यान दें कि कैसे reductorऔर sumFoldसमान हैं: उनके पास लगभग समान संरचना है! में reductorपरिभाषा sपैरामीटर उपयोग (प्रकार जिनमें से से मेल खाती है Tकी गणना के परिणाम के उपयोग से मेल खाती है) sumFold xsमें sumFoldपरिभाषा।

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

(append [4, 5, 6]) [1, 2, 3] = (foldr (:) [4, 5, 6]) [1, 2, 3] -> [1, 2, 3, 4, 5, 6]

यह हमारे पर कैसा दिखता है IntList:

appendFold :: IntList -> IntList -> IntList
appendFold ys ()          = ys
appendFold ys (Cons x xs) = x : appendFold ys xs

फिर से, चलिए लिखने की कोशिश करते हैं:

appendReductor :: IntList -> () | (Int × IntList) -> IntList
appendReductor ys ()      = ys
appendReductor ys (x, rs) = x : rs

appendFoldएक प्रलयवाद है appendReductorजिसके लिए रूपांतरित IntListहोता है IntList।

तो, अनिवार्य रूप से, एफ-अल्जेब्रा हमें पुनरावर्ती डेटास्ट्रक्चर पर 'सिलवटों' को परिभाषित करने की अनुमति देते हैं, अर्थात्, ऐसे ऑपरेशन जो हमारी संरचनाओं को कुछ मूल्य तक कम करते हैं।

एफ coalgebras

एफ-कोलजेब्रस को एफ-अल्जेब्रा के लिए 'दोहरी' शब्द कहा जाता है। वे हमें unfoldsपुनरावर्ती डेटाटिप्स के लिए परिभाषित करने की अनुमति देते हैं , अर्थात्, कुछ मूल्य से पुनरावर्ती संरचनाओं के निर्माण का तरीका।

मान लें कि आपके पास निम्न प्रकार हैं:

data IntStream = Cons (Int, IntStream)

यह पूर्णांकों की एक अनंत धारा है। इसके एकमात्र निर्माता में निम्न प्रकार हैं:

Cons :: (Int, IntStream) -> IntStream

या, सेट के संदर्भ में

Cons :: Int × IntStream -> IntStream

हास्केल आपको डेटा कंस्ट्रक्टर्स पर मिलान करने की अनुमति देता है, इसलिए आप निम्नलिखित कार्य परिभाषित कर सकते हैं IntStream:

head :: IntStream -> Int
head (Cons (x, xs)) = x

tail :: IntStream -> IntStream
tail (Cons (x, xs)) = xs

आप इन कार्यों को प्रकार के एकल कार्य में स्वाभाविक रूप से शामिल कर सकते हैं IntStream -> Int × IntStream:

head&tail :: IntStream -> Int × IntStream
head&tail (Cons (x, xs)) = (x, xs)

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

g :: T -> F T

जहां Tकुछ प्रकार है। अब से हम परिभाषित करेंगे

F1 T = Int × T

अब, एफ-कोलजेब्रा एक जोड़ी है (T, g), जहां Tएक प्रकार है और प्रकार gका एक कार्य है g :: T -> F T। उदाहरण के लिए, (IntStream, head&tail)एफ 1-कोलजेब्रा है। फिर से, जैसे कि एफ-अल्जेब्रा में, gऔर Tमनमाना हो सकता है, उदाहरण के लिए, (String, h :: String -> Int x String)कुछ एच के लिए एफ 1-कोलजेब्रा भी है।

सभी F-Coalgebras के बीच तथाकथित टर्मिनल F-Coalgebras हैं , जो प्रारंभिक F-algebras से दोहरे हैं। उदाहरण के लिए, IntStreamएक टर्मिनल F-Coalgebra है। इसका मतलब यह है कि प्रत्येक प्रकार के लिए Tऔर प्रत्येक फ़ंक्शन के लिए p :: T -> F1 Tएक फ़ंक्शन मौजूद है, जिसे एनामॉर्फिज़्म कहा जाता है , जो कि परिवर्तित Tहोता है IntStream, और ऐसा फ़ंक्शन अद्वितीय है।

निम्नलिखित फ़ंक्शन पर विचार करें, जो दिए गए एक से शुरू होने वाले पूर्णांक की एक धारा उत्पन्न करता है:

nats :: Int -> IntStream
nats n = Cons (n, nats (n+1))

अब एक फ़ंक्शन का निरीक्षण करते हैं natsBuilder :: Int -> F1 Int, जो है natsBuilder :: Int -> Int × Int:

natsBuilder :: Int -> Int × Int
natsBuilder n = (n, n+1)

फिर से, हम natsऔर के बीच कुछ समानता देख सकते हैं natsBuilder। यह उस कनेक्शन से बहुत मिलता-जुलता है जिसे हमने पहले रिडक्टर्स और सिलवटों के साथ देखा है। natsके लिए anamorphism है natsBuilder।

एक अन्य उदाहरण, एक फ़ंक्शन जो एक मान और एक फ़ंक्शन लेता है और फ़ंक्शन के क्रमिक अनुप्रयोगों की एक धारा को मान में लौटाता है:

iterate :: (Int -> Int) -> Int -> IntStream
iterate f n = Cons (n, iterate f (f n))

इसका बिल्डर फ़ंक्शन निम्नलिखित है:

iterateBuilder :: (Int -> Int) -> Int -> Int × Int
iterateBuilder f n = (n, f n)

तब के iterateलिए एक anamorphism है iterateBuilder।

निष्कर्ष

तो, संक्षेप में, एफ-अल्जेब्रस सिलवटों को परिभाषित करने की अनुमति देता है, अर्थात्, संचालन जो एक एकल मूल्य में पुनरावर्ती संरचना को कम करते हैं, और एफ-कोलजेब्रस इसके विपरीत करने की अनुमति देते हैं: एक एकल मूल्य से [संभावित] अनंत संरचना का निर्माण।

वास्तव में हास्केल एफ-अलजेब्रा और एफ-कोलजेब्रस में मेल खाता है। यह एक बहुत अच्छी संपत्ति है जो प्रत्येक प्रकार में 'नीचे' मूल्य की उपस्थिति का परिणाम है। तो हास्केल में, दोनों पुनरावर्ती प्रकार के लिए सिलवटों और अनफॉल्ड को बनाया जा सकता है। हालांकि, इसके पीछे सैद्धांतिक मॉडल जो मैंने ऊपर प्रस्तुत किया है, उससे अधिक जटिल है, इसलिए मैंने जानबूझकर इसे टाला है।

उम्मीद है की यह मदद करेगा।

Comments

प्रकार और परिभाषा appendReductorथोड़ी अजीब लगती है और इससे मुझे वास्तव में वहां के पैटर्न को देखने में मदद नहीं मिली ... :) क्या आप यह देख सकते हैं कि यह सही है? .. क्या reductor प्रकार सामान्य रूप में दिखना चाहिए? वहाँ की परिभाषा में r, F1IntList द्वारा निर्धारित किया जाता है, या यह एक मनमाना F है?

— मैक्स गालिन

Answer 3

ट्यूटोरियल पेपर के माध्यम से जाना (सह) बीजगणित और (सह) प्रेरण पर एक ट्यूटोरियल आपको कंप्यूटर विज्ञान में सह-बीजगणित के बारे में कुछ जानकारी देनी चाहिए।

नीचे आपको समझाने के लिए एक उद्धरण है,

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

---

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

एक फनकार क्या है? यह एक सेट से दूसरे में परिवर्तन है जो उनकी संरचना को संरक्षित करता है। (अधिक विस्तार के लिए नेट पर बहुत अच्छा विवरण है)।

एफ-बीजगणित क्या है? यह कवक का बीजगणित है। यह सिर्फ फनकार के सार्वभौमिक स्वामित्व का अध्ययन है।

इसे कंप्यूटर विज्ञान से कैसे जोड़ा जा सकता है? कार्यक्रम सूचना के एक संरचित सेट के रूप में देखा जा सकता है। कार्यक्रम का निष्पादन सूचना के इस संरचित सेट के संशोधन के अनुरूप है। यह अच्छा लगता है कि निष्पादन को कार्यक्रम संरचना को संरक्षित करना चाहिए। फिर निष्पादन सूचना के इस सेट पर एक फ़नकार के आवेदन के रूप में देखा जा सकता है। (कार्यक्रम को परिभाषित करने वाला एक)।

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

• डेटा जिसे प्रोग्राम द्वारा संसाधित की जा रही जानकारी के रूप में परिभाषित किया जा सकता है।
• राज्य जिसे कार्यक्रम द्वारा साझा की जा रही जानकारी के रूप में परिभाषित किया जा सकता है।

फिर इस स्तर पर, मैं कहना चाहूंगा कि;

• एफ-अलजेब्रा डेटा यूनिवर्स (जैसा कि यहां परिभाषित किया गया है) पर काम करने वाले फंक्शनल ट्रांसफॉर्मेशन का अध्ययन है।
• F-co-algebras स्टेट्स यूनिवर्स पर अभिनय फंक्शनल ट्रांसफॉर्मेशन का अध्ययन है (जैसा कि यहां परिभाषित किया गया है)।

एक कार्यक्रम के जीवन के दौरान, डेटा और राज्य सह-अस्तित्व में हैं, और वे एक-दूसरे को पूरा करते हैं। वे दोहरी हैं।

Answer 4

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

---

आइए, कुछ कंप्यूटर-वैज्ञानिकों को सहवास पर उद्धृत करें ...

http://www.cs.umd.edu/~micinski/posts/2012-09-04-on-understanding-coinduction.html

इंडक्शन परिमित डेटा के बारे में है, सह-इंडक्शन अनंत डेटा के बारे में है।

अनंत डेटा का विशिष्ट उदाहरण एक आलसी सूची (एक धारा) का प्रकार है। उदाहरण के लिए, हम कहते हैं कि हमारे पास स्मृति में निम्नलिखित वस्तु है:

 let (pi : int list) = (* some function which computes the digits of
 π. *)

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

हालाँकि, निम्नलिखित कार्यक्रम पर विचार करें:

let print_third_element (k : int list) =   match k with
     | _ :: _ :: thd :: tl -> print thd


 print_third_element pi

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

http://adam.chlipala.net/cpdt/html/Coinductive.html

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

http://www.alexandrasilva.org/#/talks.html

---

सामान्य गणितीय कार्यों से संबंधित गणितीय संदर्भ

"बीजगणित" क्या है?

बीजगणितीय संरचनाएं आम तौर पर ऐसी दिखती हैं:

1. सामग्री
2. सामान क्या कर सकता है

यह 1. गुणों और 2. विधियों के साथ वस्तुओं की तरह लगना चाहिए। या इससे भी बेहतर, यह हस्ताक्षर की तरह लगना चाहिए।

मानक गणितीय उदाहरणों में मोनोड ⊃ समूह ⊃ वेक्टर-स्पेस ⊃ "एक बीजगणित" शामिल है। Monoids ऑटोमेटा की तरह हैं: क्रिया के अनुक्रम (जैसे, f.g.h.h.nothing.f.g.f)। एक gitलॉग जो हमेशा इतिहास जोड़ता है और कभी नहीं हटाता है यह एक समूह होगा, लेकिन एक समूह नहीं। यदि आप व्युत्क्रम जोड़ते हैं (जैसे कि नकारात्मक संख्या, अंश, जड़ें, संचित इतिहास को हटाना, टूटे हुए दर्पण को अन-शेट्टर करना) तो आपको एक समूह मिलता है।

समूहों में ऐसी चीजें होती हैं जिन्हें एक साथ जोड़ा या घटाया जा सकता है। उदाहरण के लिए Durations को एक साथ जोड़ा जा सकता है। (लेकिन Dateएस नहीं कर सकते हैं) अवधि एक सदिश स्थान में रहते हैं (केवल एक समूह नहीं) क्योंकि उन्हें बाहरी संख्याओं द्वारा भी बढ़ाया जा सकता है। (एक प्रकार का हस्ताक्षर scaling :: (Number,Duration) → Duration)

बीजगणित as वेक्टर-रिक्त स्थान अभी तक एक और काम कर सकते हैं: कुछ है m :: (T,T) → T। इस "गुणन" को कॉल करें या न करें, क्योंकि एक बार छोड़ने के बाद Integersयह कम स्पष्ट होता है कि "गुणन" (या "घातांक" ) क्या होना चाहिए।

(यही कारण है कि लोगों को (श्रेणी-सैद्धांतिक) सार्वभौमिक गुण के लिए तत्पर हैं: उन्हें बताना गुणा क्या करना चाहिए करना या की तरह हो :

)

---

बीजगणित → कोलजेब्रा

Comultiplication एक तरह से परिभाषित करना आसान है जो गैर-मनमाना लगता है, तुलना में गुणा है, क्योंकि T → (T,T)आप से जाने के लिए बस एक ही तत्व को दोहरा सकते हैं। ("विकर्ण नक्शा" - वर्णक्रमीय सिद्धांत में विकर्ण मैट्रिक्स / ऑपरेटरों की तरह)

Counit आम तौर पर ट्रेस (विकर्ण प्रविष्टियों का योग) है, हालांकि फिर से जो महत्वपूर्ण है वह वही है जो आपका counit करता है ; traceमैट्रिस के लिए एक अच्छा जवाब है।

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

---

टैमिंग (संयुक्त राष्ट्र) संरचित डेटा

गणितज्ञ TQFT's की तरह कुछ मजेदार मॉडलिंग कर सकते हैं , जबकि प्रोग्रामर के साथ कुश्ती करनी है

• दिनांक / समय ( + :: (Date,Duration) → Date)
• स्थानों ( Paris≠ (+48.8567,+2.3508)! यह एक आकार, नहीं एक बात है।),
• असंरक्षित JSON जो कुछ अर्थों में सुसंगत माना जाता है,
• गलत-लेकिन-नजदीकी XML,
• अविश्वसनीय रूप से जटिल जीआईएस डेटा जो समझदार संबंधों के भार को संतुष्ट करना चाहिए,
• नियमित अभिव्यक्तियाँ जो आपके लिए कुछ मायने रखती हैं, लेकिन इसका मतलब है कि बहुत कम है।
• सीआरएम जो सभी कार्यकारी फोन नंबर और विला स्थानों, उसकी (अब पूर्व-) पत्नी और बच्चों के नाम, जन्मदिन और पिछले सभी उपहारों को धारण करना चाहिए, जिनमें से प्रत्येक को "स्पष्ट" संबंधों (ग्राहक के लिए स्पष्ट) को संतुष्ट करना चाहिए जो अविश्वसनीय हैं कोड करना कठिन है,
• .....

कंप्यूटर वैज्ञानिक, जब कोलजेब्रस के बारे में बात करते हैं, तो आमतौर पर कार्टेशियन उत्पाद की तरह, मन में सेट-ईश संचालन होता है। मेरा मानना ​​है कि लोग यही कहते हैं जब वे कहते हैं कि "अल्जब्रस हास्केल में कोलजेब्रा हैं"। लेकिन हद प्रोग्रामर जटिल की तरह डेटा-प्रकार के मॉडल करने के लिए है कि करने के लिए Place, Date/Timeऔर Customer-और उन मॉडलों वास्तविक दुनिया की तरह ज्यादा (या कम से कम असली दुनिया के अंत उपयोगकर्ता के दृष्टिकोण) के रूप में के रूप में देखने के लिए बनाने के लिए संभव-मैं duals विश्वास करते हैं, केवल सेट-वर्ल्ड से परे उपयोगी हो सकता है।