में Booleans यह AND ऑपरेटर के लिए लैम्ब्डा पथरी प्रतिनिधित्व है?क्वेरी पर लैम्ब्डा पथरी
उत्तर
लैम्बडा कैलकुस में बूलियन का प्रतिनिधित्व करने के तरीके को समझने के लिए, यह एक आईएफ अभिव्यक्ति के बारे में सोचने में मदद करता है, "अगर एक और बी और सी"। यह एक अभिव्यक्ति है जो पहली शाखा चुनती है, बी, यदि यह सत्य है, और दूसरा, सी, यदि यह गलत है। लैम्ब्डा भाव ऐसा कर सकते हैं बहुत आसानी से:
lambda(x).lambda(y).x
आप अपने तर्कों के पहले दे देंगे, और
lambda(x).lambda(y).y
आप दूसरा देता है। तो अगर एक उन भाव में से एक है, तो
a b c
या तो b
या c
देता है, जो सिर्फ हम क्या अगर करना चाहते हैं। तो
true = lambda(x).lambda(y).x
false = lambda(x).lambda(y).y
को परिभाषित करने और a b c
if a then b else c
तरह व्यवहार करेगा।
(n a b)
पर आपकी अभिव्यक्ति के अंदर देखकर, इसका अर्थ है if n then a else b
। फिर m (n a b) b
मतलब है
if m then (if n then a else b) else b
यह अभिव्यक्ति a
का मूल्यांकन करता है, तो दोनों m
और n
हैं true
, और b
अन्यथा करने के लिए। चूंकि a
आपके फ़ंक्शन का पहला तर्क है और b
दूसरा है, और true
को एक फ़ंक्शन के रूप में परिभाषित किया गया है जो उसके दो तर्कों में से पहला देता है, तो m
और n
दोनों true
हैं, तो संपूर्ण अभिव्यक्ति है। अन्यथा यह false
है। और यह सिर्फ and
की परिभाषा है!
यह सब आल्ज़ो चर्च द्वारा आविष्कार किया गया था, जिसने लैम्ब्डा कैलकुस का आविष्कार किया था।
दरअसल यह केवल एंड ऑपरेटर से थोड़ा अधिक है। यह if m and n then a else b
का लैम्ब्डा कैलकुस संस्करण है। यहां स्पष्टीकरण दिया गया है:
लैम्ब्डा कैलकुस में सत्य को दो तर्क लेने और पहले लौटने के रूप में प्रस्तुत किया जाता है। झूठी को दो तर्क लेने और दूसरे को वापस करने के रूप में दर्शाया गया है।
ऊपर दिखाया गया कार्य चार तर्क * लेता है। इसकी प्रकृति से एम और एन को बुलियन और ए और बी कुछ अन्य मूल्य माना जाता है। यदि एम सच है, तो यह अपने पहले तर्क का मूल्यांकन करेगा जो n a b
है। यह बदले में मूल्यांकन करेगा यदि एन सही है और बी अगर एन गलत है। यदि एम झूठा है, तो यह इसके दूसरे तर्क का मूल्यांकन करेगा बी।
तो मूल रूप से फ़ंक्शन एक लौटाता है यदि दोनों एम और एन सत्य हैं और अन्यथा।
(*) जहां "दो तर्क लेना" का अर्थ है "एक तर्क लेना और एक और तर्क लेने के लिए एक समारोह वापस करना"।
अपनी टिप्पणी के जवाब मेंसंपादित करें:
and true false
रूप विकि पृष्ठ पर देखा इस तरह काम करता है:
पहला कदम बस, अर्थात (λm.λn. m n m) (λa.λb. a) (λa.λb. b)
इसकी परिभाषा के साथ प्रत्येक पहचानकर्ता को बदलने के लिए है। अब फ़ंक्शन (λm.λn. m n m)
लागू है। इसका मतलब है कि m n m
में एम की हर घटना को पहले तर्क ((λa.λb. a)
) के साथ प्रतिस्थापित किया गया है और एन की प्रत्येक घटना को दूसरे तर्क ((λa.λb. b)
) के साथ प्रतिस्थापित किया गया है। तो हमें (λa.λb. a) (λa.λb. b) (λa.λb. a)
मिलते हैं। अब हम केवल (λa.λb. a)
फ़ंक्शन लागू करते हैं। चूंकि इस समारोह का शरीर बस एक है, यानी पहला तर्क, यह (λa.λb. b)
का मूल्यांकन करता है, यानी false
(λx.λy. y
का अर्थ है false
)।
आपको भी धन्यवाद! –
@sepp: क्या आप मेरी मदद कर सकते हैं, अगर आप मेरे द्वारा पोस्ट की गई दूसरी टिप्पणी पीटर के पास कर सकते हैं? –
लैम्ब्डा कैलकुस में, एक बूलियन को एक ऐसे फ़ंक्शन द्वारा दर्शाया जाता है जो दो तर्क लेता है, एक सफलता के लिए और एक विफलता के लिए। तर्क निरंतरता कहा जाता है, क्योंकि वे शेष गणना के साथ जारी रखते हैं; बुलियन ट्रू सफलता निरंतरता को बुलाता है और बूलियन झूठी विफलता निरंतरता को बुलाता है। इस कोडिंग को चर्च एन्कोडिंग कहा जाता है, और विचार यह है कि एक बूलियन "अगर-फिर-और कार्य" की तरह बहुत अधिक है।
तो हम
true = \s.\f.s
false = \s.\f.f
जहां सफलता के लिए s
खड़ा, विफलता के लिए f
खड़ा है, और बैकस्लैश एक ASCII लैम्ब्डा है कह सकते हैं।
अब मुझे आशा है कि आप देख सकते हैं कि यह कहां जा रहा है। हम and
कोड कैसे कोड करते हैं? खैर, सी में हम
n && m = n ? m : false
केवल इन कार्यों हैं करने के लिए इसे विस्तार कर सका, इसलिए
(n && m) s f = (n ? m : false) s f = n ? (m s f) : (false s f) = n ? (m s f) : f
लेकिन, त्रिगुट निर्माण, जब लैम्ब्डा पथरी में कोडित, बस है एप्लिकेशन के संचालन, तो हम है
(n && m) s f = (n m false) s f = n (m s f) (false s f) = n (m s f) f
तो अंत में हम
&& = \n . \m . \s . \f . n (m s f) f
पर पहुंचने
और यदि हम a
और b
को सफलता और विफलता निरंतरता का नाम बदलने के हम पर लौटने अपने मूल
&& = \n . \m . \a . \b . n (m a b) b
लैम्ब्डा पथरी में अन्य संगणना, विशेष रूप से चर्च एन्कोडिंग का उपयोग करते समय, यह अक्सर बातें बाहर काम करने में आसान है के रूप में बीजगणितीय कानून और समीकरण तर्क के साथ, अंत में लैम्बडा में परिवर्तित करें।
- 1. लैम्ब्डा पथरी:
- 2. लैम्ब्डा पथरी अभिव्यक्ति को लागू समारोह आवेदन
- 3. LINQ क्वेरी सिंटेक्स लैम्ब्डा
- 4. लैम्ब्डा अभिव्यक्तियों पर कोड कवरेज
- 5. लैम्ब्डा कार्यों पर हास्केल गार्ड?
- 6. लैम्ब्डा
- 7. लैम्ब्डा
- 8. लैम्ब्डा अभिव्यक्ति
- 9. लैम्ब्डा
- 10. लैम्ब्डा
- 11. लैम्ब्डा
- 12. लैम्ब्डा
- 13. "नेस्टेड फोरैच" बनाम "लैम्ब्डा/लिनक क्वेरी" प्रदर्शन (LINQ-to-Objects)
- 14. लैम्ब्डा समारोह से लैम्ब्डा अभिव्यक्ति
- 15. अभिव्यक्ति लैम्ब्डा बनाम स्टेटमेंट लैम्ब्डा
- 16. लैम्ब्डा अभिव्यक्ति वृक्ष रूपांतरण
- 17. क्वेरी
- 18. LINQ एकाधिक स्तंभों पर शामिल होने के SQL के लैम्ब्डा
- 19. सी ++ 0x: लैम्ब्डा arity पर overloading
- 20. लैम्ब्डा अभिव्यक्ति के गुणों पर इटरेटिंग
- 21. चर्च अंक: लैम्ब्डा कैलकुस में शून्य कैसे एन्कोड करें?
- 22. लैम्ब्डा अभिव्यक्ति ग्रुप सी #
- 23. सी # लिंक/लैम्ब्डा
- 24. लैम्ब्डा/LINQ
- 25. डेटाबेस पर हाइबरनेट क्वेरी
- 26. एसिंक लैम्ब्डा
- 27. लैम्ब्डा: समारोह
- 28. लैम्ब्डा समारोह
- 29. लैम्ब्डा भाव
- 30. लैम्ब्डा अभिव्यक्ति
आपको बहुत बहुत धन्यवाद !!! मुझे लगता है कि लैम्ब्डा कैलकुस वास्तव में समझना मुश्किल है और इस तरह के स्पष्टीकरण मेरे जीवन को बहुत आसान बनाते हैं !! फिर से धन्यवाद। –
@ पीटर: बस एक और मदद की ज़रूरत है, यदि आप कर सकते हैं: मैं विकिपीडिया पर चर्च बूलियन पढ़ रहा हूं: http://en.wikipedia.org/wiki/Church_encoding#Church_booleans मैं यह समझने में सक्षम नहीं हूं कि उदाहरण अनुमानित हैं यानी और सही झूठा। क्या आप उन्हें समझने में मेरी सहायता कर सकते हैं? –
उन लंबी अभिव्यक्तियों को समझने का तरीका केवल नियमों को याद रखना और उन्हें एक समय में एक कदम, बाएं से दाएं का मूल्यांकन करना है। तो अभिव्यक्ति में '(λm.λn. mnm) (λa.λb. a) (λa.λb. b) ' कोष्ठक में पहला भाग एक फ़ंक्शन है, और दूसरा और तीसरा भाग एम और एन के लिए प्रतिस्थापित हो जाता है: '(λa.λb. ए) (λa.λb. बी) (λa.λb. ए)'। फिर एक ही बात फिर से करें, याद रखें कि प्रत्येक कोष्ठक में ए और बी एक-दूसरे से पूरी तरह से स्वतंत्र हैं। पहला भाग, '(λa.λb. ए)', अपने दो तर्कों में से पहला लौटाता है। तो यह '(λa.λb. बी) 'लौटाता है, जो चर्च का झूठा प्रतिनिधित्व है। –