इसके लगभग एक साल बाद, मुझे एहसास हुआ कि मैंने पोस्ट करने से पहले कुछ महत्वपूर्ण शोध को याद किया था।
जोत दो अपेक्षाकृत सरल कॉम्बिनेटरों 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
अपने स्वयं के प्रयोगों से, जोत छोटे कार्यक्रमों की ओर जाता है, धीरे-धीरे पुष्टि की जा रही है क्योंकि मेरा कार्यक्रम सरल कार्यों को सीखता है, उनकी रचना करता है, फिर एक बेहतर छत से बड़े कार्यों को सीखता है।