सपाट भावों के लिए सरलतम पूर्ण संयोजन आधार जोड़ी


9

क्रिस ओकासाकी के पेपर "फ्लैटनिंग कॉम्बिनेटर: सर्वाइविंग विदआउट पेरेंटेस " में उन्होंने दिखाया कि दो कॉम्बिनेटर एक एप्लीकेशन ऑपरेटर या कोष्ठक की आवश्यकता के बिना ट्यूरिंग-पूर्ण अभिव्यक्ति को एन्कोड करने के लिए पर्याप्त और आवश्यक दोनों हैं।

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

हालांकि ओकासाकी की एन्कोडिंग लैम्ब्डा कैलकुलस शब्दों से लेकर बिटस्ट्रिंग्स तक एकतरफा मैपिंग में सबसे अधिक मददगार साबित हुई थी, जरूरी नहीं कि इस कमी में इस्तेमाल किए गए दो कॉम्बीनेटर के रूप में दूसरा तरीका अपेक्षाकृत जटिल हो जब व्यावहारिक प्रतिस्थापन निर्देश के रूप में उपयोग किया जाता है।

सरलतम पूर्ण संयोजन आधार जोड़ी क्या है जिसे एप्लिकेशन ऑपरेटर की आवश्यकता नहीं है?


1
निश्चित नहीं है कि क्या प्रासंगिक है, लेकिन ध्यान दें: एक शब्द द्वारा गठित लैम्ब्डा कैलकुलस के आधार हैं । इससे गोडेल की संख्या और भी सरल हो जाती है। cs.uu.nl/research/techreps/repo/CS-1989/1989-14.pdf
ची

जवाबों:


2

इसके लगभग एक साल बाद, मुझे एहसास हुआ कि मैंने पोस्ट करने से पहले कुछ महत्वपूर्ण शोध को याद किया था।

जोत दो अपेक्षाकृत सरल कॉम्बिनेटरों B & X के साथ जो मैं पूछ रहा था उसके बिल को फिट करने के लिए लगता है जिसे एक कॉम्पैक्ट गोएडेल नंबरिंग द्वारा दर्शाया जा सकता है।

मैंने पायथन के साथ उनके संदर्भ कार्यान्वयन को सरल बनाया है:

def S(x): return lambda y: lambda z: x(z)(y(z))
def K(x): return lambda y: x
def X(x): return x(S)(K)
def B(x): return lambda y: lambda z: x(y(z))
def I(x): return x
def J(n): return (B if n & 1 else X)(J(n >> 1)) if n else I

J (n) अपने Goedel नंबर n द्वारा दर्शाए गए प्रोग्राम को दर्शाते हुए बिल्ट अप फंक्शन देता है।

बी (चर्च एन्कोडेड के समान गुणा) कार्यात्मक अनुप्रयोग (कोष्ठक) के कार्य करता है, और एकल-आधार Iota कॉम्बिनेटर एक्स के एस / के हिस्सों को अलग कर सकता है।

इस भाषा के कुछ महत्वपूर्ण गुण हैं जो मैं (लगभग) बेशर्मी से भाषा के आविष्कारक क्रिस बार्कर की वेबसाइट से चोरी कर रहा हूं, लगभग 2000।

वाक्यविन्यास लेकिन ट्यूरिंग-पूर्ण में जोत एक नियमित भाषा है। आप J (n) के कार्यान्वयन से देख सकते हैं कि यदि कोई होस्ट भाषा पूंछ-पुनरावृत्ति का समर्थन करती है, तो बिटस्ट्रिंग प्रोग्राम प्रारूप को पार्स करने के लिए कोई स्टैक स्थान की आवश्यकता नहीं है।

ट्यूरिंग-पूर्णता का प्रमाण क्रिस की साइट से भी आता है, एस और के कॉम्बिनेटर का उपयोग करके पहले से ही ज्ञात ट्यूरिंग-पूर्ण संयोजन तर्क को लागू करना:

K  ==> 11100
S  ==> 11111000
AB ==> 1[A][B], where A & B are arbitrary CL combinators built up from K & S

Jot में कोई सिंटैक्स त्रुटियां नहीं हैं, प्रत्येक प्रोग्राम जो Goedel नंबर n दिया गया है वह एक वैध प्रोग्राम है। यह संभवतः मेरे स्वयं के अनुसंधान का सबसे महत्वपूर्ण पहलू है, क्योंकि यह न केवल तुच्छता के लिए पार्सिंग को सरल करता है, बल्कि सिद्धांत रूप में जोत को किसी भी ट्यूरिंग-पूर्ण एन्कोडिंग की तुलना में कहीं अधिक पार्सिमोनियस बनाना चाहिए जिसे विकृत कार्यक्रमों को छोड़ना पड़ता है।

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

यह वर्तमान में केवल मेरे सीमित संसाधनों के साथ ~ 40 बिट तक काम करता है। मैं बहुत बड़े कार्यक्रमों को सीखने के लिए सैट सॉल्वर के साथ फिर से लिखने का प्रयास कर रहा हूं। यदि आप जानते हैं कि बूलियन फॉर्मूला के रूप में बंधे हुए नेस्टेड बंद को कैसे अनियंत्रित किया जाता है, तो कृपया मेरे नए प्रश्न के साथ मदद करें ।

अब जॉन ट्रम्प के बाइनरी लैम्ब्डा कैलकुलस के लिए कुछ दिलचस्प तुलना के लिए, जो अपनी संक्षिप्तता के लिए जाना जाता है, लेकिन इसमें संभावित सिंटैक्स त्रुटियों की समस्या है। निम्नलिखित कार्यक्रम कुछ ही सेकंड में मेरे सीखने के कार्यक्रम द्वारा उत्पन्न किए गए थे।

Function    Jot       Binary Lambda Calculus   |J| |B|
--------|----------|--------------------------|---|---
SUCC      J(18400)  "000000011100101111011010" 15  24
CHURCH_0  J(154)    "000010"                    8   6
CHURCH_1  J(0)      "00000111010"               1  11
CHURCH_2  J(588826) "0000011100111010"         20  16
IS_ZERO   J(5)      "00010110000000100000110"   3  23
MUL       J(280)    "0000000111100111010"       9  19
EXP       J(18108)  "00000110110"              15  11
S         J(8)      "00000001011110100111010"   4  23
K         J(4)      "0000110"                   3   7
AND       J(16)     "0000010111010000010"       5  19
OR        J(9050)   "00000101110000011010"     14  20

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.