Y फेस a3 few के सामान्य रूप को प्राप्त करने के लिए कुछ सौ कमी कदम भी कई हैं?

Question

जैसा कि मैंने हाल ही में λ-पथरी के आधार को पढ़ाया है, मैंने सामान्य लिस्प में एक साधारण λ-पथरी मूल्यांकनकर्ता को लागू किया है। जब मैं Y fac 3सामान्य-क्रम में कमी के सामान्य रूप से पूछता हूं , तो इसमें 619 कदम होते हैं, जो थोड़ा ज्यादा लगता था।

बेशक, हर बार जब मैंने कागज पर समान कटौती की, तो मैंने कभी भी अनपेक्षित λ-पथरी का उपयोग नहीं किया, लेकिन उन पर काम करने वाले संख्याओं और कार्यों को जोड़ा। इस स्थिति में, फेस को इस प्रकार परिभाषित किया गया है:

fac = λfac.λn.if (= n 0) 1 (* n (fac (- n 1)))

इस मामले में, विचार करना =, *और -करी कार्यों के रूप में, इसे Y fac 3अपने सामान्य रूप में लाने के लिए केवल लगभग 50 कदम हैं 6।

लेकिन मेरे मूल्यांकनकर्ता में, मैंने निम्नलिखित का उपयोग किया:

true = λx.λy.x
false = λx.λy.y
⌜0⌝ = λf.λx.x
succ = λn.λf.λx.f n f x
⌜n+1⌝ = succ ⌜n⌝
zero? = λn.n (λx.false) true
mult = λm.λn.λf.m (n f)
pred = λn.λf.λx.n (λg.λh.h (g f)) (λu.x) (λu.u)
fac = λfac.λn.(zero? n) ⌜1⌝ (* n (fac (pred n)))
Y = λf.(λf.λx.f (x x)) f ((λf.λx.f (x x)) f)

619 चरणों में, मैं Y fac ⌜3⌝सामान्य रूप से ⌜6⌝, अर्थात् λf.λx.f (f (f (f (f (f x)))))।

कई चरणों के त्वरित स्किमिंग से, मुझे लगता है कि यह predउस वारंट की परिभाषा है जो इतनी लंबी कमी है, लेकिन मुझे अभी भी आश्चर्य है कि क्या यह सिर्फ मेरे कार्यान्वयन में एक बड़ा बुरा बग हो सकता है ...

संपादित करें: मैंने शुरू में एक हजार कदमों के बारे में पूछा था, जिनमें से कुछ वास्तव में सामान्य आदेश के गलत कार्यान्वयन के कारण थे, इसलिए मैं प्रारंभिक चरणों की संख्या के 2/3 पर पहुंच गया। जैसा कि नीचे टिप्पणी की गई है, मेरे वर्तमान कार्यान्वयन के साथ, चर्च से पीनो अंकगणित पर स्विच करने से वास्तव में चरणों की संख्या बढ़ जाती है ...

Answer 1

यदि आप उपयोग करना चाहते हैं तो चर्च कोडिंग वास्तव में खराब है pred। मैं आपको पीनो शैली में कुछ और कुशल कोडिंग का उपयोग करने की सलाह दूंगा:

// अंकगणित

: p_zero = λs.λz.z
: p_one = λs.λz.s p_zero
: p_succ = λn.λs.λz.sn
: p_null = λn.n (λx। ff) tt
: p_pred = λn.n (λp.p) p_zero
: p_plus = μ! f.λn.λm.n (λp। p_succ (fpm)) m
: p_subs = μ! f.λn.λm.n (λp। p_pred ((f))) m
: p_eq = μ! f.λm.λn m (λp। n (λq। fpq) ff) (n (λx.ff) tt)
: p_mult = μ! f.λm.λn m (λp। p_plus n (! fpn)) p_zero
: p_exp = μ! f.λm.λn। m (λp। p_mult n ((fpn)) p_one
: p_even = μ! f.λm। m (λp। (fp) नहीं) tt

// नंबर

: p_0 = λs.λz.z
: p_1 = λs.λz.s p_0
: p_2 = λs.λz.s p_1
: p_3 = λs.λz.s p_2
...

यह मेरे पुराने पुस्तकालयों में से एक से लिया गया कुछ कोड है, और μ!f. …इसके लिए सिर्फ एक अनुकूलित निर्माण था Y (λf. …)। (और tt, ff, notबूलियन्स कर रहे हैं।)

मुझे वास्तव में यकीन नहीं है कि आप इसके लिए बेहतर परिणाम प्राप्त करेंगे fac।

Comments

टिप के लिए धन्यवाद, इस वैकल्पिक एन्कोडिंग के साथ काम करने से मुझे अपने कार्यान्वयन में कुछ कीड़े खोजने में मदद मिली। वास्तव में, यह चरणों की संख्या के लिए मदद नहीं करता है, क्योंकि फिक्सिंग के बाद, 3 का सामान्य रूप ढूंढना! चर्च के अंकों के साथ 619 कदम और पीनो अंकों के साथ 687…

— कहीं भी नहीं है आदमी

हां, यही मैंने सोचा था, क्योंकि Yशॉर्ट रिडक्शन प्राप्त करने के लिए कुछ विशेष कटौती नियम का उपयोग यहां (विशेष रूप से पीनो अंक के लिए) महत्वपूर्ण लगता है।

— स्टीफन जिमेनेज़

बस जिज्ञासु, क्या 4 के बारे में !, 5 !, 6! ?

— स्टीफन जिमेनेज़

अजीब तरह से पर्याप्त, 3 के बाद!, Peano एन्कोडिंग अधिक कुशल हो जाता है कि चर्च एन्कोडिंग। क्रमशः 1 !, 2 !, 3 !, 4 का सामान्य रूप प्राप्त करने के लिए! और ५! पीनो / ​​चर्च के साथ, यह 10/10, 40/33, 157/134, 685/667, 3541/3956 और 21629/27311 कदम रखता है। 6 के लिए चरणों की संख्या लगभग! पिछले डेटा से प्रक्षेप करके पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है।

— कहीं

ऐसा लगता है कि उपर्युक्त ठीक स्कॉट अंक "पीनो + λ = स्कॉट" हैं। कुछ और जो कोशिश करने लायक होगा, वह है उनके बाइनरी वेरिएंट (चर्च और <हड़ताल> पीनो </ हड़ताल> स्कॉट) के लिए।

— स्टीफन जिमेनेज़

Answer 2

अगर मैं सोचता हूं कि पायथन में 3 की फैक्टरियल की गणना करने के लिए सीपीयू कितनी चीजों को करता है, तो कुछ सौ की कटौती कोई बड़ी बात नहीं है।