View source for चर्च एन्कोडिंग

{{short description|Representation of the natural numbers as higher-order functions}}
गणित में, चर्च एन्कोडिंग [[लैम्ब्डा कैलकुलस]] में डेटा और ऑपरेटरों का प्रतिनिधित्व करने का साधन है। चर्च अंक लैम्ब्डा संकेतन का उपयोग करते हुए प्राकृतिक संख्याओं का प्रतिनिधित्व करते हैं। विधि का नाम [[अलोंजो चर्च]] के नाम पर रखा गया है, जिसने सबसे पहले लैम्ब्डा कैलकुलस में डेटा को इस तरह से एनकोड किया था।

सामान्यतः अन्य संकेतन (जैसे पूर्णांक, बूलियन, जोड़े, सूचियाँ और टैग किए गए संघ) में आदिम माने जाने वाले शब्दों को चर्च एन्कोडिंग के अनुसार उच्च-क्रम के कार्यों में मैप किया जाता है। [[चर्च-ट्यूरिंग थीसिस]] का प्रमाणित है कि किसी भी संगणनीय ऑपरेटर (और उसके संचालन) को चर्च एन्कोडिंग के अनुसार प्रदर्शित किया जा सकता है। लैम्ब्डा कैलकुलस में एकमात्र आदिम डेटा प्रकार फलन है।

== प्रयोग ==

चर्च एन्कोडिंग का सीधा कार्यान्वयन <math>O(1)</math> को <math>O(n)</math> तक कुछ पहुंच संचालन को धीमा कर देता है , जहां <math>n</math> डेटा संरचना का आकार है, जो चर्च एन्कोडिंग को अव्यावहारिक हो जाती है।<ref name=Widemann>{{cite journal |last1=Trancón y Widemann |first1=Baltasar |last2=Parnas |first2=David Lorge |title=सारणीबद्ध भाव और कुल कार्यात्मक प्रोग्रामिंग|journal=Implementation and Application of Functional Languages |series=Lecture Notes in Computer Science |date=2008 |volume=5083 |pages=228–229 |doi=10.1007/978-3-540-85373-2_13|isbn=978-3-540-85372-5 |url=https://books.google.com/books?id=E1zuY1Q6sOsC&pg=PA228}}</ref> शोध से पता चला है कि इसे लक्षित अनुकूलन द्वारा संबोधित किया जा सकता है, किन्तु अधिकांश [[कार्यात्मक प्रोग्रामिंग]] भाषाएं इसके अतिरिक्त [[बीजगणितीय डेटा प्रकार|बीजगणितीय डेटा प्रकारों]] को सम्मिलित करने के लिए अपने मध्यवर्ती प्रतिनिधित्वों का विस्तार करती हैं।<ref>{{cite book |last1=Jansen |first1=Jan Martin |last2=Koopman |first2=Pieter W. M. |last3=Plasmeijer |first3=Marinus J. |editor1-last=Nilsson |editor1-first=Henrik |title=Trends in functional programming. Volume 7 |date=2006 |publisher=Intellect |location=Bristol |isbn=978-1-84150-188-8 |chapter=Efficient interpretation by transforming data types and patterns to functions|pages=73–90|citeseerx=10.1.1.73.9841}}</ref> वैसे भी, चर्च एन्कोडिंग अधिकांशतः सैद्धांतिक तर्कों में प्रयोग किया जाता है, क्योंकि यह आंशिक मूल्यांकन और प्रमेय सिद्ध करने के लिए प्राकृतिक प्रतिनिधित्व है।<ref name=Widemann/> संचालन को उच्च-सीमा वाले प्रकारों का उपयोग करके टाइप किया जा सकता है,<ref>{{cite web |work=Lambda Calculus and Lambda Calculators |url=https://okmij.org/ftp/Computation/lambda-calc.html#predecessor |publisher=okmij.org|title=Predecessor and lists are not representable in simply typed lambda calculus}}</ref> और आदिम पुनरावर्तन आसानी से सुलभ है।<ref name=Widemann/> यह धारणा कि फलन केवल आदिम डेटा प्रकार हैं, कई प्रमाणों को सुव्यवस्थित करते हैं।

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

== चर्च अंक ==

चर्च अंक चर्च एन्कोडिंग के अनुसार [[प्राकृतिक संख्या]]ओं का प्रतिनिधित्व करते हैं। प्राकृतिक संख्या n का प्रतिनिधित्व करने वाला उच्च-क्रम फलन ऐसा फलन है जो किसी फलन <math>f</math> इसकी एन-गुना फलन संरचना के लिए मैप करता है। सरल शब्दों में, अंक का मान उस संख्या के समान होता है जितनी बार फलन अपने तर्क को समाहित करता है।

: <math>f^{\circ n} = \underbrace{f \circ f \circ \cdots \circ f}_{n\text{ times}}.\,</math>
सभी चर्च अंक ऐसे फलन हैं जो दो पैरामीटर लेते हैं। चर्च अंक 0, 1, 2, ..., को लैम्ब्डा कैलकुस में निम्नानुसार परिभाषित किया गया है।

प्रारंभिक 0 फलन को बिल्कुल भी प्रयुक्त नहीं करना 1 फलन को एक बार प्रयुक्त करना, 2 फलन को दो बार प्रयुक्त करना, 3 फलन को तीन बार प्रयुक्त करना आदि:

:<math>
\begin{array}{r|l|l}
\text{Number} & \text{Function definition} & \text{Lambda expression} \\
\hline
0 & 0\ f\ x = x & 0 = \lambda f.\lambda x.x 
\\
1 & 1\ f\ x = f\ x & 1 = \lambda f.\lambda x.f\ x 
\\
2 & 2\ f\ x = f\ (f\ x) & 2 = \lambda f.\lambda x.f\ (f\ x) 
\\
3 & 3\ f\ x = f\ (f\ (f\ x)) & 3 = \lambda f.\lambda x.f\ (f\ (f\ x))
\\
\vdots & \vdots & \vdots
\\
n & n\ f\ x = f^n\ x & n = \lambda f.\lambda x.f^{\circ n}\ x
\end{array}
</math>
चर्च अंक 3 किसी दिए गए फलन को तीन बार मान पर प्रयुक्त करने की क्रिया का प्रतिनिधित्व करता है। आपूर्ति किया गया फलन पहले आपूर्ति किए गए पैरामीटर पर प्रयुक्त होता है और उसके बाद क्रमिक रूप से अपने परिणाम पर प्रयुक्त होता है। अंतिम परिणाम अंक 3 नहीं है (जब तक आपूर्ति पैरामीटर 0 नहीं होता है और फलन उत्तराधिकारी फलन होता है)। फलन स्वयं, और इसका अंतिम परिणाम नहीं चर्च अंक 3 है। चर्च अंक 3 का अर्थ केवल तीन बार कुछ भी करना है। यह तीन बार से क्या कारण है इसका व्यापक परिभाषा प्रदर्शन है।

=== चर्च अंकों के साथ गणना ===

संख्याओं पर [[अंकगणित|अंकगणितीय]] संक्रियाओं को चर्च अंकों पर कार्यों द्वारा दर्शाया जा सकता है। इन कार्यों को लैम्ब्डा कैलकुस में परिभाषित किया जा सकता है, या अधिकांश कार्यात्मक प्रोग्रामिंग भाषाओं में कार्यान्वित किया जा सकता है (लैम्ब्डा अभिव्यक्ति को फलन में परिवर्तित करना देखें))।

अतिरिक्त फलन <math>\operatorname{plus}(m, n)= m+n</math> पहचान का उपयोग करता है <math>f^{\circ (m+n)}(x)=f^{\circ m}(f^{\circ n}(x))</math>.

: <math>\operatorname{plus} \equiv \lambda m.\lambda n.\lambda f.\lambda x. m\ f\ (n\ f\ x)</math>
उत्तराधिकारी फलन <math>\operatorname{succ}(n)=n+1</math> बीटा रिडक्शन या सीई.बी2-रिडक्शन β-समतुल्य है <math>(\operatorname{plus}\ 1)</math>.

: <math>\operatorname{succ} \equiv \lambda n.\lambda f.\lambda x. f\ (n\ f\ x)</math>
गुणन फलन <math>\operatorname{mult}(m, n) = m*n</math> पहचान का उपयोग करता है <math>f^{\circ (m*n)}(x) = (f^{\circ n})^{\circ m}(x)</math>.

: <math>\operatorname{mult} \equiv \lambda m.\lambda n.\lambda f.\lambda x. m\ (n\ f)\ x</math>
घातांक फलन <math>\operatorname{exp}(m, n) = m^n</math> चर्च अंकों की परिभाषा द्वारा दिया गया है, <math>n\ h\ x = h^n\ x </math>. परिभाषा में स्थानापन्न <math> h \to m, x \to f</math> पाने के <math>n\ m\ f = m^n\ f </math> और,
: <math>\operatorname{exp}\ m\ n = m^n = n\ m </math>
जो लैम्ब्डा अभिव्यक्ति देता है,
: <math>\operatorname{exp} \equiv \lambda m.\lambda n. n\ m</math>

 <math>\operatorname{pred}(n)</math> h> फलन को समझना अधिक कठिन है।

: <math>\operatorname{pred} \equiv \lambda n.\lambda f.\lambda x. n\ (\lambda g.\lambda h. h\ (g\ f))\ (\lambda u. x)\ (\lambda u. u)</math>
एक चर्च अंक n बार फलन प्रयुक्त करता है। पूर्ववर्ती फलन को फलन वापस करना चाहिए जो इसके पैरामीटर n - 1 बार प्रयुक्त करता है। यह f और x के चारों ओर कंटेनर बनाकर प्राप्त किया जाता है, जिसे इस तरह से प्रारंभ किया जाता है कि फलन के आवेदन को पहली बार छोड़ दिया जाता है। अधिक विस्तृत विवरण के लिए पूर्ववर्ती फलन की या व्युत्पत्ति देखें।

घटाव फलन पूर्ववर्ती फलन के आधार पर लिखा जा सकता है।

: <math>\operatorname{minus} \equiv  \lambda m.\lambda n. (n \operatorname{pred})\ m</math>


=== चर्च अंकों पर कार्यों की तालिका ===

{| class="wikitable"
|-
! फलन !! बीजगणित !! पहचान !! फलन परिभाषा
! colspan="2" | लैम्ब्डा भाव 
|-
| [[Successor function|उत्तराधिकारी]] || <math>n + 1</math> || <math>f^{n+1}\ x = f (f^n x) </math> ||  <math>\operatorname{succ}\ n\ f\ x = f\ (n\ f\ x) </math> || <math>\lambda n.\lambda f.\lambda x.f\ (n\ f\ x) </math> || ...
|-
| [[Addition|जोड़ना]] || <math>m + n</math> || <math>f^{m+n}\ x = f^m (f^n x) </math> || <math>\operatorname{plus}\ m\ n\ f\ x = m\ f\ (n\ f\ x) </math> || <math> \lambda m.\lambda n.\lambda f.\lambda x.m\ f\ (n\ f\ x) </math> || <math>\lambda m.\lambda n.n \operatorname{succ} m</math>
|-
| [[Multiplication|गुणन]] || <math>m * n </math> || <math> f^{m*n}\ x = (f^m)^n\ x </math> ||<math>\operatorname{multiply}\ m\ n\ f\ x = m\ (n\ f) \ x </math> || <math>\lambda m.\lambda n.\lambda f.\lambda x.m\ (n\ f) \ x </math> || <math>\lambda m.\lambda n.\lambda f.m\ (n\ f) </math>
|-
| [[Exponentiation|घातांक]] || <math>m^n </math> || <math> n\ m\ f = m^n\ f </math>{{efn|name=Church numeral definition|This formula is the definition of a Church numeral {{mvar|n}} with <math>f \to m, x \to f</math>.}} ||<math>\operatorname{exp} \ m\ n\ f\ x = (n\ m)\ f\ x </math> || <math> \lambda m.\lambda n.\lambda f.\lambda x.(n\ m)\ f\ x </math> || <math> \lambda m.\lambda n.n\ m </math>
|-
| [[Index.php?title=चर्च एन्कोडिंग#Derivation of पूर्वाधिकारी function|पूर्वाधिकारी]]{{efn|name=ce}} || <math>n - 1</math> || <math>\operatorname{inc}^n \operatorname{con} = \operatorname{val} (f^{n-1} x) </math> || <math>if (n == 0)\ 0\ else\ (n-1)</math> 
| colspan="2" |
<math>\lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u) </math>
|-
| [[Subtraction|घटाव]]{{efn|name=ce}} [[Subtraction|(मोनस)]]  || <math> m - n </math> || <math>f^{m-n}\ x = (f^{-1})^n (f^{m} x)</math> || <math>\operatorname{minus}\ m\ n = (n \operatorname{pred})\ m</math>  || ... ||  <math>\lambda m.\lambda n.n \operatorname{pred} m</math>
|}

{{A Note}} {{notelist|refs={{efn|name=ce|In the Church encoding,
* <math> \operatorname{pred}(0) = 0 </math>
* <math> m \le n \to m - n = 0 </math>
}}}}

=== पूर्ववर्ती फलन की व्युत्पत्ति ===

चर्च एन्कोडिंग में प्रयुक्त पूर्ववर्ती फलन है,

:<math>\operatorname{pred}(n) = \begin{cases} 0 & \mbox{if }n=0, \\ n-1 & \mbox{otherwise}\end{cases}</math>.

पूर्ववर्ती बनाने के लिए हमें फलन को 1 कम समय में प्रयुक्त करने का एक विधि चाहिए। एक अंक {{mvar|n}} फलन {{mvar|f}} {{mvar|n}} बार {{mvar|x}} पर प्रयुक्त होता है। फलन {{math|''n''-1}} बार प्रयुक्त करने के लिए पूर्ववर्ती फलन को अंक {{mvar|n}} का उपयोग करना चाहिए।

पूर्ववर्ती फलन को प्रयुक्त करने से पहले, यहां एक योजना है जो मान को कंटेनर फलन में लपेटती है। हम {{mvar|f}} और {{mvar|x}} के स्थान पर उपयोग करने के लिए नए कार्यों को परिभाषित करेंगे, जिन्हें {{math|inc}} और {{math|init}} कहा जाता है। कंटेनर फलन को + कहा जाता है। तालिका के बाईं ओर {{math|inc}} और {{math|init}} पर प्रयुक्त अंक {{mvar|n}} दिखाता है।

:<math>
\begin{array}{r|r|r}
\text{Number} & \text{Using init} & \text{Using const}
\\
\hline
0 &
\operatorname{init} = \operatorname{value}\ x &
\\
1 &
\operatorname{inc}\ \operatorname{init} = \operatorname{value}\ (f\ x) &
\operatorname{inc}\ \operatorname{const} = \operatorname{value}\ x 
\\
2 &
\operatorname{inc}\ (\operatorname{inc}\ \operatorname{init}) = \operatorname{value}\ (f\ (f\ x)) &
\operatorname{inc}\ (\operatorname{inc}\ \operatorname{const}) = \operatorname{value}\ (f\ x)
\\
3 &
\operatorname{inc}\ (\operatorname{inc}\ (\operatorname{inc}\ \operatorname{init})) = \operatorname{value}\ (f\ (f\ (f\ x))) &
\operatorname{inc}\ (\operatorname{inc}\ (\operatorname{inc}\ \operatorname{const})) = \operatorname{value}\ (f\ (f\ x))
\\
\vdots & \vdots & \vdots
\\
n &
n \operatorname{inc}\ \operatorname{init} = \operatorname{value}\ (f^n\ x) = \operatorname{value}\ (n\ f\ x) &
n \operatorname{inc}\ \operatorname{const} = \operatorname{value}\ (f^{n-1}\ x) = \operatorname{value}\ ((n-1)\ f\ x) \\
\end{array}
</math>
सामान्य पुनरावृत्ति नियम है
:<math> \operatorname{inc}\ (\operatorname{value}\ v) = \operatorname{value}\ (f\ v)</math>
यदि कंटेनर से मान प्राप्त करने के लिए कोई फलन भी है ( {{math|extract}} कहा जाता है),
:<math> \operatorname{extract}\ (\operatorname{value}\ v) = v</math>
तब {{math|extract}} का उपयोग {{math|samenum}} कार्य को परिभाषित करने के लिए किया जा सकता है,
: <math>\operatorname{samenum} = \lambda n.\lambda f.\lambda x.\operatorname{extract}\ (n \operatorname{inc} \operatorname{init})  = \lambda n.\lambda f.\lambda x.\operatorname{extract}\ (\operatorname{value}\ (n\ f\ x)) = \lambda n.\lambda f.\lambda x.n\ f\ x = \lambda n.n</math>

 {{math|samenum}um}} कार्य आंतरिक रूप से उपयोगी नहीं है। चूँकि, जैसा कि {{math|inc}} प्रतिनिधियों ने अपने कंटेनर तर्क के लिए {{mvar|f}} को कॉल किया है, हम यह व्यवस्थित कर सकते हैं कि पहले एप्लिकेशन {{math|inc}} पर एक विशेष कंटेनर प्राप्त होता है जो {{mvar|f}} के पहले एप्लिकेशन को छोड़ने की अनुमति देने वाले इसके तर्क को अनदेखा करता है। इस नए प्रारंभिक कंटेनर को कॉल करें। उपरोक्त तालिका का दाहिना भाग {{mvar|n}} {{math|inc}} {{math|const}} के विस्तार को दर्शाता है। फिर {{math|same}} फलन के व्यंजक में {{math|init}} को {{math|const}} से प्रतिस्थापित करने पर हमें पूर्ववर्ती फलन प्राप्त होता है,

:<math>\operatorname{pred} = \lambda n.\lambda f.\lambda x.\operatorname{extract}\ (n \operatorname{inc} \operatorname{const}) = \lambda n.\lambda f.\lambda x.\operatorname{extract}\ (\operatorname{value}\ ((n-1)\ f\ x)) = \lambda n.\lambda f.\lambda x.(n-1)\ f\ x = \lambda n.(n-1)</math>
जैसा कि कार्यों के नीचे समझाया गया है {{math|inc}}, {{math|init}}, {{math|const}}, {{math|value}} और {{math|extract}} के रूप में परिभाषित किया जा सकता है,
:<math>\begin{align}
\operatorname{value} &= \lambda v.(\lambda h.h\ v) \\
\operatorname{extract} k &= k\ \lambda u.u \\
\operatorname{inc} &= \lambda g.\lambda h.h\ (g\ f) \\
\operatorname{init} &= \lambda h.h\ x \\
\operatorname{const} &= \lambda u.x 
\end{align}</math>
जो {{math|pred}} के रूप में लैम्ब्डा अभिव्यक्ति देता है जैसा,
: <math>\operatorname{pred} = \lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u) </math>

{| वर्ग = विकिटेबल
|- |-
| संरेखित = 'शीर्ष' |

==== वैल्यू कंटेनर ====

मान कंटेनर फलन को उसके मान पर प्रयुक्त करता है। इसके द्वारा परिभाषित किया गया है,
:<math> \operatorname{value}\ v\ h = h\ v </math>
इसलिए,
:<math> \operatorname{value} = \lambda v.(\lambda h.h\ v) </math>

===== इंक =====
{{math|inc}nc}} फलन को {{mvar|v}} युक्त मान लेना चाहिए, और {{mvar|f v}} युक्त एक नया मान वापस करना चाहिए।
:<math> \operatorname{inc}\ (\operatorname{value}\ v) = \operatorname{value}\ (f\ v)</math>
g को मान कंटेनर होने दें,
:<math> g = \operatorname{value}\ v</math>
तब,
:<math> g\ f = \operatorname{value}\ v\ f = f\ v</math>
इसलिए,
:<math> \operatorname{inc}\ g = \operatorname{value}\ (g\ f) </math>
:<math> \operatorname{inc} = \lambda g.\lambda h.h\ (g\ f) </math>
| संरेखित = 'शीर्ष' |

==== निकालें ====

पहचान फलन प्रयुक्त करके मान निकाला जा सकता है,
:<math> I = \lambda u.u </math>
{{mvar|I}} का उपयोग करते हुए ,
:<math> \operatorname{value}\ v\ I = v </math>
इसलिए,
:<math> \operatorname{extract}\ k = k\ I </math>


==== स्थिरांक ====

{{math|pred}} को प्रयुक्त करने के लिए {{math|init}} फलन को उस {{math|const}} से बदल दिया जाता है जो f प्रयुक्त नहीं होता है। हमें संतुष्ट करने के लिए {{math|const}} की आवश्यकता है,
:<math> \operatorname{inc}\ \operatorname{const} = \operatorname{value}\ x </math>
:<math> \lambda h.h\ (\operatorname{const}\ f) = \lambda h.h\ x </math>
जो संतुष्ट है यदि ,
:<math> \operatorname{const}\ f = x </math>
या लैम्ब्डा अभिव्यक्ति के रूप में,
:<math> \operatorname{const} = \lambda u.x </math>
|}

==== पूर्व को परिभाषित करने का अन्य विधि ====

जोड़े का उपयोग करके पूर्व को भी परिभाषित किया जा सकता है:
:<math>\begin{align}
\operatorname{f} =&\ \lambda p.\ \operatorname{pair}\ (\operatorname{second}\ p)\ (\operatorname{succ}\ (\operatorname{second}\ p)) \\
\operatorname{zero} =&\ (\lambda f.\lambda x.\ x) \\
\operatorname{pc0} =&\ \operatorname{pair}\ \operatorname{zero}\ \operatorname{zero} \\
\operatorname{pred} =&\ \lambda n.\ \operatorname{first}\ (n\ \operatorname{f}\ \operatorname{pc0}) \\
\end{align}</math>
यह सरल परिभाषा है, किन्तु पूर्व के लिए अधिक जटिल अभिव्यक्ति की ओर ले जाती है।

के लिए विस्तार <math>\operatorname{pred} \operatorname{three}</math>:
:<math>\begin{align}
\operatorname{pred} \operatorname{three} =&\ \operatorname{first}\ (\operatorname{f}\ (\operatorname{f}\ (\operatorname{f}\ (\operatorname{pair}\ \operatorname{zero}\ \operatorname{zero})))) \\
=&\ \operatorname{first}\ (\operatorname{f}\ (\operatorname{f}\ (\operatorname{pair}\ \operatorname{zero}\ \operatorname{one}))) \\
=&\ \operatorname{first}\ (\operatorname{f}\ (\operatorname{pair}\ \operatorname{one}\ \operatorname{two})) \\
=&\ \operatorname{first}\ (\operatorname{pair}\ \operatorname{two}\ \operatorname{three}) \\
=&\ \operatorname{two}
\end{align}</math>


=== विभाग ===

प्राकृतिक संख्याओं का विभाजन (गणित) किसके द्वारा कार्यान्वित किया जा सकता है,<ref>
{{cite web
|last=Allison
|first=Lloyd
|title=Lambda Calculus Integers
|url=http://www.csse.monash.edu.au/~lloyd/tildeFP/Lambda/Examples/const-int/}}
</ref>
: <math> n/m = \operatorname{if}\ n \ge m\ \operatorname{then}\ 1 + (n-m)/m\ \operatorname{else}\ 0 </math>
<math>n-m</math> की गणना करने में कई बीटा कटौती होती है। जब तक हाथ से कटौती नहीं कर रहा है, इससे कोई फर्क नहीं पड़ता, किन्तु यह उत्तम है कि इस गणना को दो बार न करना पड़े। परीक्षण संख्याओं के लिए सबसे सरल विधेय इस्ज़ेरो है इसलिए स्थिति पर विचार करें।
: <math> \operatorname{IsZero}\ (\operatorname{minus}\ n\ m) </math>
किन्तु यह स्थिति <math> n \le m </math> के समतुल्य है, न कि <math> n<m </math> यदि इस अभिव्यक्ति का उपयोग किया जाता है तो ऊपर दी गई विभाजन की गणितीय परिभाषा को चर्च के अंकों पर कार्य में अनुवादित किया जाता है,
: <math> \operatorname{divide1}\ n\ m\ f\ x = (\lambda d.\operatorname{IsZero}\ d\ (0\ f\ x)\ (f\ (\operatorname{divide1}\ d\ m\ f\ x)))\ (\operatorname{minus}\ n\ m) </math>
वांछित के रूप में, इस परिभाषा में <math> \operatorname{minus}\ n\ m </math> के लिए एक ही कॉल है। चूँकि परिणाम यह है कि यह सूत्र <math>(n-1)/ m</math> का मान देता है।

विभाजित करने से पहले n में 1 जोड़कर इस समस्या को ठीक किया जा सकता है। विभाजन की परिभाषा तब है,
: <math> \operatorname{divide}\ n = \operatorname{divide1}\ (\operatorname{succ}\ n) </math>
विभाजित 1 पुनरावर्ती परिभाषा है। पुनरावर्तन को प्रयुक्त करने के लिए [[फिक्स्ड-पॉइंट कॉम्बिनेटर]] का उपयोग किया जा सकता है। डिव बाय; नामक नया फलन बनाएँ;
* वाम भाग में <math> \operatorname{divide1} \rightarrow \operatorname{div} \ c</math>
* दाहिने हाथ में <math> \operatorname{divide1} \rightarrow c </math>
पाने के लिए और,
: <math> \operatorname{div} = \lambda c.\lambda n.\lambda m.\lambda f.\lambda x.(\lambda d.\operatorname{IsZero}\ d\ (0\ f\ x)\ (f\ (c\ d\ m\ f\ x)))\ (\operatorname{minus}\ n\ m) </math>
तब,
:<math> \operatorname{divide} = \lambda n.\operatorname{divide1}\ (\operatorname{succ}\ n) </math>
जहां ,
: <math>\begin{align}
 \operatorname{divide1} &= Y\ \operatorname{div} \\
 \operatorname{succ} &= \lambda n.\lambda f.\lambda x. f\ (n\ f\ x) \\
 Y &= \lambda f.(\lambda x.f\ (x\ x))\ (\lambda x.f\ (x\ x)) \\
 0 &= \lambda f.\lambda x.x\\
 \operatorname{IsZero} &= \lambda n.n\ (\lambda x.\operatorname{false})\ \operatorname{true}
\end{align}</math>
:: <math>\begin{align}
\operatorname{true} &\equiv \lambda a.\lambda b.a\\
\operatorname{false} &\equiv \lambda a.\lambda b.b
\end{align}</math>
: <math>\begin{align}
\operatorname{minus} &= \lambda m.\lambda n.n \operatorname{pred} m\\
\operatorname{pred} &= \lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u) 
\end{align}</math>
देता है,
: <math>\scriptstyle \operatorname{divide} = \lambda n.((\lambda f.(\lambda x.x\ x)\ (\lambda x.f\ (x\ x)))\ (\lambda c.\lambda n.\lambda m.\lambda f.\lambda x.(\lambda d.(\lambda n.n\ (\lambda x.(\lambda a.\lambda b.b))\ (\lambda a.\lambda b.a))\ d\ ((\lambda f.\lambda x.x)\ f\ x)\ (f\ (c\ d\ m\ f\ x)))\ ((\lambda m.\lambda n.n (\lambda n.\lambda f.\lambda x.n\ (\lambda g.\lambda h.h\ (g\ f))\ (\lambda u.x)\ (\lambda u.u)) m)\ n\ m)))\ ((\lambda n.\lambda f.\lambda x. f\ (n\ f\ x))\ n) </math>
या {{mvar|&lambda;}} के लिए \ का उपयोग कर पाठ के रूप में
 डिवाइड = (\n.((\f.(\x.x x) (\x.f (x x))) (\c.\n.\m.\f.\x.(\d.(\n.n (\x) .(\a.\b.b)) (\a.\b.a)) d ((\f.\x.x) f x) (f (c d m f x))) ((\m.\n.n (\n.\f.\) x.n (\g.\h.h (g f)) (\u.x) (\u.u)) m) n m))) ((\n.\f.\x. f (n f x)) n))

उदाहरण के लिए, 9/3 द्वारा दर्शाया गया है
 डिवाइड (\f.\x.f (f (f (f (f (f (f (f (f x)))))))) (\f.\x.f (f (f x)))

लैम्ब्डा कैलकुलस कैलकुलेटर का उपयोग करते हुए, सामान्य क्रम का उपयोग करते हुए, उपरोक्त अभिव्यक्ति 3 तक कम हो जाती है।
 \f.\x.f (f (f (x)))

=== हस्ताक्षरित संख्या ===

चर्च अंकों को [[पूर्णांक]] तक विस्तारित करने के लिए सरल दृष्टिकोण चर्च जोड़ी का उपयोग करना है, जिसमें चर्च अंक सकारात्मक और ऋणात्मक मान का प्रतिनिधित्व करते हैं।<ref>
{{cite web
|last=Bauer
|first=Andrej
|title=Andrej's answer to a question; "Representing negative and complex numbers using lambda calculus"
|url=https://cs.stackexchange.com/q/2272
}}</ref> पूर्णांक मान दो चर्च अंकों के बीच का अंतर है।

एक प्राकृतिक संख्या को हस्ताक्षरित संख्या में परिवर्तित किया जाता है,

:<math>\operatorname{convert}_s = \lambda x.\operatorname{pair}\ x\ 0 </math>
मानो की अदला-बदली करके ऋणात्मकता का प्रदर्शन किया जाता है।

:<math>\operatorname{neg}_s = \lambda x.\operatorname{pair}\ (\operatorname{second}\ x)\ (\operatorname{first}\ x) </math>
यदि जोड़ी में से शून्य है तो पूर्णांक मान अधिक स्वाभाविक रूप से प्रदर्शित होता है। OneZero फलन इस स्थिति को प्राप्त करता है,

:<math>\operatorname{OneZero} = \lambda x.\operatorname{IsZero}\ (\operatorname{first}\ x)\ x\ (\operatorname{IsZero}\ (\operatorname{second}\ x)\ x\ (\operatorname{OneZero}\ \operatorname{pair}\ (\operatorname{pred}\ (\operatorname{first}\ x))\ (\operatorname{pred}\ (\operatorname{second}\ x))))</math>
रिकर्सन को वाई कॉम्बिनेटर का उपयोग करके कार्यान्वित किया जा सकता है,
:<math>\operatorname{OneZ} = \lambda c.\lambda x.\operatorname{IsZero}\ (\operatorname{first}\ x)\ x\ (\operatorname{IsZero}\ (\operatorname{second}\ x)\ x\ (c\ \operatorname{pair}\ (\operatorname{pred}\ (\operatorname{first}\ x))\ (\operatorname{pred}\ (\operatorname{second}\ x))))</math>
:<math>\operatorname{OneZero} = Y \operatorname{OneZ}</math>


=== प्लस और माइनस ===

जोड़ी पर जोड़ को गणितीय रूप से परिभाषित किया गया है,
:<math>x + y = [x_p, x_n] + [y_p, y_n] = x_p - x_n + y_p - y_n = (x_p + y_p) - (x_n + y_n) = [x_p + y_p, x_n + y_n] </math>
अंतिम अभिव्यक्ति का लैम्ब्डा कैलकुलस में अनुवाद किया गया है,
:<math>\operatorname{plus}_s = \lambda x.\lambda y.\operatorname{OneZero}\ (\operatorname{pair}\ (\operatorname{plus}\ (\operatorname{first}\ x)\ (\operatorname{first}\ y))\ (\operatorname{plus}\ (\operatorname{second}\ x)\ (\operatorname{second}\ y))) </math>
इसी प्रकार घटाव परिभाषित किया गया है,
:<math>x - y = [x_p, x_n] - [y_p, y_n] = x_p - x_n - y_p + y_n = (x_p + y_n) - (x_n + y_p) = [x_p + y_n, x_n + y_p] </math>
देना,
:<math>\operatorname{minus}_s = \lambda x.\lambda y.\operatorname{OneZero}\ (\operatorname{pair}\ (\operatorname{plus}\ (\operatorname{first}\ x)\ (\operatorname{second}\ y))\ (\operatorname{plus}\ (\operatorname{second}\ x)\ (\operatorname{first}\ y))) </math>


=== गुणा और भाग ===

गुणन द्वारा परिभाषित किया जा सकता है,
:<math>x*y = [x_p, x_n]*[y_p, y_n] =(x_p - x_n)*(y_p - y_n) = (x_p*y_p + x_n*y_n) - (x_p*y_n + x_n*y_p) = [x_p*y_p + x_n*y_n, x_p*y_n + x_n*y_p]</math>
अंतिम अभिव्यक्ति का लैम्ब्डा कैलकुलस में अनुवाद किया गया है,
:<math>\operatorname{mult}_s = \lambda x.\lambda y.\operatorname{pair}\ 
(\operatorname{plus}\ 
(\operatorname{mult}\ (\operatorname{first}\ x)\ (\operatorname{first}\ y))\ 
(\operatorname{mult}\ (\operatorname{second}\ x)\ (\operatorname{second}\ y)))\ 
(\operatorname{plus}\ 
(\operatorname{mult}\ (\operatorname{first}\ x)\ (\operatorname{second}\ y))\ 
(\operatorname{mult}\ (\operatorname{second}\ x)\ (\operatorname{first}\ y))) </math>
विभाजन के लिए यहाँ समान परिभाषा दी गई है, इस परिभाषा को छोड़कर, प्रत्येक जोड़ी में मान शून्य होना चाहिए (ऊपर वनजीरो देखें)। DivZ फलन हमें शून्य घटक वाले मान को अनदेखा करने की अनुमति देता है।
:<math>\operatorname{divZ} = \lambda x.\lambda y.\operatorname{IsZero}\ y\ 0 \ (\operatorname{divide}\ x\ y) </math>
divZ का उपयोग तब निम्न सूत्र में किया जाता है, जो गुणन के समान है, किन्तु divZ द्वारा प्रतिस्थापित बहु के साथ है ।

:<math>\operatorname{divide}_s = \lambda x.\lambda y.\operatorname{pair}\ 
(\operatorname{plus}\ 
(\operatorname{divZ}\ (\operatorname{first}\ x)\ (\operatorname{first}\ y))\ 
(\operatorname{divZ}\ (\operatorname{second}\ x)\ (\operatorname{second}\ y)))\ 
(\operatorname{plus}\ 
(\operatorname{divZ}\ (\operatorname{first}\ x)\ (\operatorname{second}\ y))\ 
(\operatorname{divZ}\ (\operatorname{second}\ x)\ (\operatorname{first}\ y))) </math>


=== परिमेय और वास्तविक संख्याएं ===

लैम्ब्डा कैलकुस में तर्कसंगत और [[गणना योग्य संख्या]] भी एन्कोड की जा सकती है। तर्कसंगत संख्याओं को हस्ताक्षरित संख्याओं की जोड़ी के रूप में एन्कोड किया जा सकता है। संगणनीय वास्तविक संख्याओं को सीमित प्रक्रिया द्वारा एन्कोड किया जा सकता है जो गारंटी देता है कि वास्तविक मान से अंतर संख्या से भिन्न होता है जो कि हमारी आवश्यकता के अनुसार छोटा हो सकता है।<ref>
{{cite web|url=https://wiki.haskell.org/Exact_real_arithmetic|title=Exact real arithmetic|last=|first=|date=|website=Haskell|url-status=live|archive-url=https://web.archive.org/web/20150326164041/https://wiki.haskell.org/Exact_real_arithmetic |archive-date=2015-03-26 |access-date=}}
</ref>

<ref>
{{cite web
|last=Bauer
|first=Andrej
|title=Real number computational software|website=[[GitHub]]
|date=26 September 2022
|url=https://github.com/andrejbauer/marshall}}
</ref> दिए गए संदर्भ सॉफ्टवेयर का वर्णन करते हैं जो सैद्धांतिक रूप से लैम्ब्डा कैलकुलस में अनुवादित हो सकते हैं। बार वास्तविक संख्या परिभाषित हो जाने के बाद जटिल संख्याएं स्वाभाविक रूप से वास्तविक संख्याओं की जोड़ी के रूप में एन्कोडेड होती हैं।

ऊपर वर्णित डेटा प्रकार और फलन प्रदर्शित करते हैं कि लैम्ब्डा कैलकुलस में किसी भी डेटा प्रकार या गणना को एन्कोड किया जा सकता है। यह चर्च-ट्यूरिंग थीसिस है।

=== अन्य अभ्यावेदन के साथ अनुवाद ===
अधिकांश वास्तविक विश्व की भाषाओं में मशीन-देशी पूर्णांकों का समर्थन है; चर्च और अनचर्च फलन गैर-ऋणात्मक पूर्णांक और उनके संबंधित चर्च अंकों के बीच परिवर्तित होते हैं। फलन यहां [[हास्केल (प्रोग्रामिंग भाषा)]] में दिए गए हैं, जहां <code>\</code> लैम्ब्डा कैलकुस के λ के अनुरूप है। अन्य भाषाओं में कार्यान्वयन समान हैं।

<syntaxhighlight lang="haskell">

type Church a = (a -> a) -> a -> a

church :: Integer -> Church Integer
church 0 = \f -> \x -> x
church n = \f -> \x -> f (church (n-1) f x)

unchurch :: Church Integer -> Integer
unchurch cn = cn (+ 1) 0
</syntaxhighlight>


== चर्च बूलियन्स ==

चर्च बूलियन सच्चे और झूठे बूलियन मानो के चर्च एन्कोडिंग हैं। कुछ प्रोग्रामिंग भाषाएं इन्हें बूलियन अंकगणित के कार्यान्वयन मॉडल के रूप में उपयोग करती हैं; उदाहरण स्मालटाक और [[पिको (प्रोग्रामिंग भाषा)]] हैं।

बूलियन तर्क को विकल्प के रूप में माना जा सकता है। सच और झूठ का चर्च एन्कोडिंग दो मापदंडों के फलन हैं:
* सच पहला पैरामीटर चुनता है।
* झूठा दूसरा पैरामीटर चुनता है।

दो परिभाषाओं को चर्च बूलियंस के रूप में जाना जाता है:
: <math>\begin{align}
\operatorname{true} &\equiv \lambda a.\lambda b.a\\
\operatorname{false} &\equiv \lambda a.\lambda b.b
\end{align}</math>
यह परिभाषा विधेय (अर्थात सत्य मान लौटाने वाले कार्य) को सीधे-सीधे क्रिया-खंड के रूप में फलन करने की अनुमति देती है। बूलियन लौटाने वाला फलन जिसे दो पैरामीटर पर प्रयुक्त किया जाता है, या तो पहला या दूसरा पैरामीटर देता है:
: <math>\operatorname{predicate-}x\ \operatorname{then-clause}\ \operatorname{else-clause} </math>
तत्कालीन खंड का मूल्यांकन करता है यदि विधेय-एक्स सत्य का मूल्यांकन करता है और अन्य-खंड का मूल्यांकन करता है यदि विधेय-एक्स गलत का मूल्यांकन करता है।

क्योंकि सत्य और असत्य पहले या दूसरे पैरामीटर का चयन करते हैं, उन्हें लॉजिक ऑपरेटर प्रदान करने के लिए संयोजित किया जा सकता है। ध्यान दें कि नहीं के कई संभावित कार्यान्वयन हैं।
: <math>\begin{align}
\operatorname{and} &= \lambda p.\lambda q.p\ q\ p\\
\operatorname{or} &= \lambda p.\lambda q.p\ p\ q\\
\operatorname{not}_1 &= \lambda p.\lambda a.\lambda b.p\ b\ a\\
\operatorname{not}_2 &= \lambda p.p\ (\lambda a.\lambda b. b)\ (\lambda a.\lambda b. a) = \lambda p.p \operatorname{false} \operatorname{true}\\
\operatorname{xor} &= \lambda a.\lambda b.a\ (\operatorname{not}\ b)\ b\\
\operatorname{if} &= \lambda p.\lambda a.\lambda b.p\ a\ b
\end{align}</math>
कुछ उदाहरण:

: <math>\begin{align}

\operatorname{and} \operatorname{true} \operatorname{false} &= (\lambda p.\lambda q.p\ q\ p)\ \operatorname{true}\ \operatorname{false} = \operatorname{true} \operatorname{false} \operatorname{true} = (\lambda a.\lambda b.a) \operatorname{false} \operatorname{true} = \operatorname{false} 
\\
\operatorname{or} \operatorname{true} \operatorname{false} &= (\lambda p.\lambda q.p\ p\ q)\ (\lambda a.\lambda b.a)\ (\lambda a.\lambda b.b) = (\lambda a.\lambda b.a)\ (\lambda a.\lambda b.a)\ (\lambda a.\lambda b.b) = (\lambda a.\lambda b.a) = \operatorname{true}
\\
\operatorname{not}_1\ \operatorname{true} &= (\lambda p.\lambda a.\lambda b.p\ b\ a) (\lambda a.\lambda b.a) = \lambda a.\lambda b.(\lambda a.\lambda b.a)\ b\ a = \lambda a.\lambda b.(\lambda c.b)\ a = \lambda a.\lambda b.b = \operatorname{false} 
\\
\operatorname{not}_2\ \operatorname{true} &= (\lambda p.p\ (\lambda a.\lambda b. b) (\lambda a.\lambda b. a)) (\lambda a.\lambda b. a) = (\lambda a.\lambda b. a) (\lambda a.\lambda b. b) (\lambda a.\lambda b. a) = (\lambda b. (\lambda a.\lambda b. b))\ (\lambda a.\lambda b. a) = \lambda a.\lambda b.b = \operatorname{false} 
\end{align}</math>


== विधेय ==

एक विधेय एक ऐसा कार्य है जो एक बूलियन मान लौटाता है। सबसे मौलिक विधेय <math>\operatorname{IsZero}</math> है, जो <math>\operatorname{true}</math> लौटाता है यदि इसका तर्क चर्च अंक <math>0</math> है, और <math>\operatorname{false}</math> यदि इसका तर्क कोई अन्य चर्च अंक है:
: <math>\operatorname{IsZero} = \lambda n.n\ (\lambda x.\operatorname{false})\ \operatorname{true}</math>
निम्नलिखित विधेय परीक्षण करता है कि क्या पहला तर्क दूसरे से कम-से-या-समान है:
: <math>\operatorname{LEQ} = \lambda m.\lambda n.\operatorname{IsZero}\ (\operatorname{minus}\ m\ n)</math>,

पहचान के कारण,
: <math> x = y \equiv (x \le y \land y \le x) </math>
समानता के लिए परीक्षण के रूप में प्रयुक्त किया जा सकता है,
: <math>\operatorname{EQ} = \lambda m.\lambda n.\operatorname{and}\ (\operatorname{LEQ}\ m\ n)\ (\operatorname{LEQ}\ n\ m) </math>


== चर्च जोड़े ==
{{see also|दोष}}
चर्च जोड़े विपक्ष (दो-टुपल) प्रकार के चर्च एन्कोडिंग हैं। जोड़ी को फलन के रूप में दर्शाया गया है जो फलन तर्क लेता है। जब इसका तर्क दिया जाता है तो यह तर्क जोड़ी के दो घटकों पर प्रयुक्त होगा। लैम्ब्डा कैलकुस में परिभाषा है,

: <math>\begin{align}
\operatorname{pair} &\equiv \lambda x.\lambda y.\lambda z.z\ x\ y \\
\operatorname{first} &\equiv \lambda p.p\ (\lambda x.\lambda y.x) \\
\operatorname{second} &\equiv \lambda p.p\ (\lambda x.\lambda y.y) 
\end{align}
</math>
उदाहरण के लिए,
: <math>\begin{align}
   & \operatorname{first}\ (\operatorname{pair}\ a\ b) \\
 = & (\lambda p.p\ (\lambda x.\lambda y.x))\ ((\lambda x.\lambda y.\lambda z.z\ x\ y)\ a\ b) \\
 = & (\lambda p.p\ (\lambda x.\lambda y.x))\ (\lambda z.z\ a\ b) \\
 = & (\lambda z.z\ a\ b)\ (\lambda x.\lambda y.x) \\
 = & (\lambda x.\lambda y.x)\ a\ b = a 
\end{align}
</math>


== सूची एन्कोडिंग ==

सूची नोड्स से ([[अपरिवर्तनीय वस्तु]]) [[सूची (कंप्यूटिंग)]] का निर्माण किया जाता है। सूची पर मूल संचालन हैं;

{| class="wikitable"
|-
! कार्य !! विवरण
|-
| ''शून्य'' || एक खाली सूची बनाएँ।
|-
| ''इस्निल'' || सूची खाली होने पर परीक्षण करें।
|-
| ''दोष'' || किसी दिए गए मान को (संभवतः खाली) सूची में जोड़ें।
|-
| ''शीर्ष'' || सूची का पहला तत्व प्राप्त करें।
|-
| ''अंतिम भाग'' || बाकी सूची प्राप्त करें।
|}
हम नीचे सूचियों के चार अलग-अलग प्रतिनिधित्व देते हैं:
* प्रत्येक सूची नोड को दो जोड़े से बनाएं (खाली सूचियों की अनुमति देने के लिए)।
* प्रत्येक सूची नोड को जोड़ी से बनाएँ।
* फोल्ड (उच्च-क्रम फलन ) का उपयोग करके सूची का प्रतिनिधित्व करें।
* स्कॉट के एन्कोडिंग का उपयोग करके सूची का प्रतिनिधित्व करें जो मिलान अभिव्यक्ति के स्थितियों को तर्क के रूप में लेता है

===== सूची नोड के रूप में दो जोड़े =====
एक चर्च जोड़ी द्वारा गैर-खाली सूची को प्रयुक्त किया जा सकता है;
* सबसे पहले सिर होता है।
* दूसरे में पूंछ होती है।

चूँकि यह खाली सूची का प्रतिनिधित्व नहीं देता है क्योंकि कोई अशक्त सूचक नहीं है। शून्य का प्रतिनिधित्व करने के लिए, जोड़ी को दूसरी जोड़ी में लपेटा जा सकता है, जिससे तीन मान मिलते हैं:
* सबसे पहले - अशक्त सूचक (खाली सूची)।
* दूसरा। पहले में सिर होता है।
* दूसरा। दूसरे में पूंछ होती है।

इस विचार का उपयोग करते हुए मूल सूची संचालन को इस प्रकार परिभाषित किया जा सकता है:<ref>{{cite book
  | last = Pierce
  | first = Benjamin C.
  | authorlink = Benjamin C. Pierce
  | title = [[Types and Programming Languages]]
  | publisher = [[MIT Press]]
  | year = 2002
  | pages = 500
  | isbn = 978-0-262-16209-8}}</ref>

{| class="wikitable"
|-
! अभिव्यक्ति !! विवरण
|-
| <math> \operatorname{nil} \equiv \operatorname{pair}\ \operatorname{true}\ \operatorname{true} </math>
| जोड़ी का पहला तत्व सत्य है जिसका अर्थ है कि सूची शून्य है।
|-
| <math> \operatorname{isnil} \equiv \operatorname{first} </math>
| अशक्त (या खाली सूची) सूचक को पुनः प्राप्त करें।
|-
| <math> \operatorname{cons}  \equiv \lambda h.\lambda t.\operatorname{pair} \operatorname{false}\  (\operatorname{pair} h\ t) </math>
| एक सूची नोड बनाएँ, जो शून्य नहीं है, और इसे हेड एच और टेल टी दें।
|-
|<math> \operatorname{head}  \equiv \lambda z.\operatorname{first}\ (\operatorname{second} z) </math>
| दूसरा.पहला ''शीर्ष'' है।
|-
| <math> \operatorname{tail}  \equiv \lambda z.\operatorname{second}\ (\operatorname{second} z) </math>
| दूसरा.दूसरा''अंतिम भाग'' है।
|}
एक शून्य नोड में दूसरा कभी भी एक्सेस नहीं किया जाता है, परंतु कि 'सिर' और 'पूंछ' केवल गैर-खाली सूचियों पर प्रयुक्त हों।

'''सूची नोड के रूप में एक जोड़ी'''

वैकल्पिक रूप से परिभाषित करें<ref>{{cite book |first=John |last=Tromp |chapter=14. Binary Lambda Calculus and Combinatory Logic |editor-last=Calude |editor-first=Cristian S |title=यादृच्छिकता और जटिलता, लीबनिज से चैतिन तक|chapter-url=https://books.google.com/books?id=flPICgAAQBAJ&pg=PP1 |date=2007 |publisher=World Scientific |isbn=978-981-4474-39-9 |pages=237–262}}<br/>As PDF: {{cite web |first=John |last=Tromp |title=Binary Lambda Calculus and Combinatory Logic |date=14 May 2014 |publisher= |url=https://tromp.github.io/cl/LC.pdf |access-date=2017-11-24}}</ref>
: <math>\begin{align}
\operatorname{cons}  &\equiv \operatorname{pair} \\
\operatorname{head}  &\equiv \operatorname{first} \\
\operatorname{tail}  &\equiv \operatorname{second} \\
\operatorname{nil}   &\equiv \operatorname{false} \\
\operatorname{isnil} &\equiv \lambda l.l (\lambda h.\lambda t.\lambda d.\operatorname{false}) \operatorname{true} 
\end{align}</math>
जहां अंतिम परिभाषा सामान्य का विशेष स्थति है
: <math>\operatorname{process-list} \equiv \lambda l.l (\lambda h.\lambda t.\lambda d. \operatorname{head-and-tail-clause}) \operatorname{nil-clause}  </math>

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

: <math>
\begin{align}
\operatorname{nil} &\equiv \lambda c.\lambda n.n\\
\operatorname{isnil} &\equiv \lambda l.l\ (\lambda h.\lambda t.\operatorname{false})\ \operatorname{true}\\
\operatorname{cons} &\equiv \lambda h.\lambda t.\lambda c.\lambda n.c\ h\ (t\ c\ n)\\
\operatorname{head} &\equiv \lambda l.l\ (\lambda h.\lambda t.h)\ \operatorname{false}\\

\operatorname{tail} &\equiv \lambda l.\lambda c.\lambda n.l\ (\lambda h.\lambda t.\lambda g.g\ h\ (t\ c))\ (\lambda t.n)\ (\lambda h.\lambda t.t)
\end{align}</math>
इस सूची प्रतिनिधित्व को [[सिस्टम एफ|प्रणाली एफ]] में टाइप किया जा सकता है।

===== स्कॉट एन्कोडिंग का उपयोग करके सूची का प्रतिनिधित्व करें =====
एक वैकल्पिक प्रतिनिधित्व स्कॉट एन्कोडिंग है जो निरंतरता के विचार का उपयोग करता है और सरल कोड को जन्म दे सकता है।<ref>{{cite book
 | last = Jansen | first = Jan Martin
 | editor1-last = Achten | editor1-first = Peter
 | editor2-last = Koopman | editor2-first = Pieter W. M.
 | contribution = Programming in the λ-Calculus: From Church to Scott and Back
 | doi = 10.1007/978-3-642-40355-2_12
 | pages = 168–180
 | publisher = Springer
 | series = Lecture Notes in Computer Science
 | title = The Beauty of Functional Code - Essays Dedicated to Rinus Plasmeijer on the Occasion of His 61st Birthday
 | volume = 8106
 | year = 2013}}</ref> (मोजेन्सन-स्कॉट एन्कोडिंग भी देखें)।

इस दृष्टिकोण में, हम इस तथ्य का उपयोग करते हैं कि प्रतिरूप मिलान अभिव्यक्ति का उपयोग करके सूचियों को देखा जा सकता है। उदाहरण के लिए, [[ स्काला (प्रोग्रामिंग भाषा) |स्काला (प्रोग्रामिंग भाषा)]] नोटेशन का उपयोग करते हुए, यदि <code>List</code> खाली सूची <code>Nil</code> और कंस्ट्रक्टर Cons(h, t) के साथ प्रकार <code>list</code> के मान को दर्शाती है, तो हम सूची का निरीक्षण कर सकते हैं और सूची के खाली होने की स्थिति में <code>nilCode</code> और {{code|consCode(h, t)}} की गणना कर सकते हैं। सूची खाली नहीं है:
<syntaxhighlight lang="scala">
list match {
  case Nil        => nilCode
  case Cons(h, t) => consCode(h,t)
}
</syntaxhighlight>
 यह {{code|list}st}} दी गई है कि यह {{code|nilCode}} और {{code|consCode}}पर कैसे कार्य करता है। इसलिए हम एक सूची को एक फलन के रूप में परिभाषित करते हैं जो ऐसे {{code|nilCode}}और {{code|consCode}}को तर्कों के रूप में स्वीकार करता है, जिससे उपरोक्त प्रतिरूप मिलान के अतिरिक्त हम बस लिख सकें:
:<math>
\operatorname{list}\ \operatorname{nilCode}\ \operatorname{consCode}
</math>
आइए {{code|nilCode}} के अनुरूप पैरामीटर {{code|n}} द्वारा और {{code|consCode}}के अनुरूप पैरामीटर {{code|c}} द्वारा निरूपित करें। खाली सूची वह है जो शून्य तर्क लौटाती है:
: <math>
\operatorname{nil} \equiv \lambda n. \lambda c.\ n
</math>
सिर के साथ गैर-खाली सूची {{code|h}} और पूंछ {{code|t}} द्वारा दिया गया है
: <math>
\operatorname{cons}\ h\ t\ \ \equiv\ \ \lambda n.\lambda c.\ c\ h\ t
</math>
अधिक सामान्यतः <math>m</math> विकल्पों के साथ बीजगणितीय डेटा प्रकार <math>m</math> पैरामीटर के साथ एक फलन बन जाता है। जब iवें कंस्ट्रक्टर में <math>n_i</math> तर्क होते हैं, तो एन्कोडिंग के संबंधित पैरामीटर <math>n_i</math> तर्क भी लेते हैं।

स्कॉट एन्कोडिंग अनटाइप्ड लैम्ब्डा कैलकुलस में किया जा सकता है, जबकि टाइप्स के साथ इसके उपयोग के लिए रिकर्सन और टाइप पॉलीमोर्फिज्म के साथ टाइप प्रणाली की आवश्यकता होती है। इस प्रतिनिधित्व में तत्व प्रकार E के साथ सूची जिसका उपयोग प्रकार C के मानो की गणना करने के लिए किया जाता है, निम्नलिखित पुनरावर्ती प्रकार की परिभाषा होगी, जहां '=>' फलन प्रकार को दर्शाता है:
<syntaxhighlight lang="scala">
type List = 
  C =>                    // nil argument
  (E => List => C) =>     // cons argument
  C                       // result of pattern matching
</syntaxhighlight>


एक सूची जिसका उपयोग मनमानी प्रकारों की गणना करने के लिए किया जा सकता है, में एक प्रकार होगा जो <code>C</code>से अधिक मात्रा में होता है। <code>E</code> में एक सामान्य सूची भी <code>E</code> को प्रकार तर्क के रूप में ले जाएगा।

== यह भी देखें ==
* लैम्ब्डा कैलकुलस
* टाइप किए गए कलन में चर्च अंकों के लिए प्रणाली एफ
* मोगेनसेन-स्कॉट एन्कोडिंग
* क्रमसूचक संख्या या वॉन न्यूमैन क्रमसूचकों की परिभाषा - प्राकृतिक संख्याओं को सांकेतिक शब्दों में बदलने का दूसरा विधि: समुच्चय के रूप में

== संदर्भ ==
<references/>

*{{cite journal |first=A. |last=Stump |title=Directly reflective meta-programming |journal=Higher-Order Symb Comput |volume=22 |issue= 2|pages=115–144 |date=2009 |doi=10.1007/s10990-007-9022-0 |url=http://www.cs.uiowa.edu/~astump/papers/archon.pdf |citeseerx=10.1.1.489.5018|s2cid=16124152 }}
*{{cite web |url=http://www.cs.rice.edu/~javaplt/311/Readings/supplemental.pdf |title=Church numerals and booleans explained |first=Robert |last=Cartwright |work=Comp 311 — Review 2 |publisher=[[Rice University]]}}
*{{cite thesis |first=Colin |last=Kemp |title=Theoretical Foundations for Practical 'Totally Functional Programming' |date=2007 |type=PhD |publisher=School of Information Technology and Electrical Engineering, The University of Queensland |chapter-url=https://espace.library.uq.edu.au/view/UQ:171001 |citeseerx=10.1.1.149.3505 |chapter=§2.4.1 Church Naturals, §2.4.2 Church Booleans, Ch. 5 Derivation techniques for TFP |pages=14–17, 93–145}} All about Church and other similar encodings, including how to derive them and operations on them, from first principles
*[http://www.csse.monash.edu.au/~lloyd/tildeFP/Lambda/Examples/const-int/ Some interactive examples of Church numerals]
*[http://blog.klipse.tech/lambda/2016/07/24/lambda-calculus-2.html Lambda Calculus Live Tutorial: Boolean Algebra]

{{Mathematical logic}}
{{Alonzo Church}}

[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category:Collapse templates]]
[[Category:Created On 18/05/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Mathematics navigational boxes]]
[[Category:Navbox orphans]]
[[Category:Navigational boxes| ]]
[[Category:Navigational boxes without horizontal lists]]
[[Category:Pages with empty portal template]]
[[Category:Pages with script errors]]
[[Category:Philosophy and thinking navigational boxes]]
[[Category:Portal-inline template with redlinked portals]]
[[Category:Sidebars with styles needing conversion]]
[[Category:Template documentation pages|Documentation/doc]]
[[Category:Templates Translated in Hindi]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates generating microformats]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that are not mobile friendly]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]
[[Category:Wikipedia metatemplates]]
[[Category:लैम्ब्डा कैलकुलस]]