ขั้นตอนการลดลงสองสามร้อยครั้งนั้นมากเกินไปที่จะได้รูปแบบปกติของ Y fac ⌜3⌝หรือไม่?

เมื่อฉันได้สอนพื้นฐานของ calcul-แคลคูลัสเมื่อเร็ว ๆ นี้ฉันได้ติดตั้ง evalu-แคลคูลัสธรรมดาใน Common LISP เมื่อฉันถามรูปแบบปกติของY fac 3การลดอันดับปกติมันใช้เวลา 619 ขั้นตอนซึ่งดูเหมือนจะค่อนข้างมาก

แน่นอนว่าทุกครั้งที่ฉันลดกระดาษที่คล้ายกันฉันไม่เคยใช้λ-แคลคูลัสที่ไม่มีการพิมพ์ แต่เพิ่มตัวเลขและฟังก์ชั่นการใช้งาน ในกรณีนี้ fac ถูกกำหนดเช่น:

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

ในกรณีนี้พิจารณา=, *และ-เป็นความดีความชอบฟังก์ชั่นมันใช้เวลาเพียงประมาณ 50 ขั้นตอนที่จะได้รับไปสู่รูปแบบปกติY fac 36

แต่ในผู้ประเมินของฉันฉันใช้สิ่งต่อไปนี้:

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 ของจำนวนขั้นตอนเริ่มต้น ตามความเห็นด้านล่างด้วยการใช้งานปัจจุบันของฉันการเปลี่ยนจาก Church เป็น Peano เลขคณิตจริง ๆ แล้วจะเพิ่มจำนวนขั้นตอน ...

predคริสตจักรเข้ารหัสไม่ดีจริงๆถ้าคุณต้องการที่จะใช้ ฉันขอแนะนำให้คุณใช้การเข้ารหัสที่มีประสิทธิภาพยิ่งขึ้นในสไตล์ Peano:

// arithmetics

: 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 (! fpm)) 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มี booleans.)

ฉันไม่ได้จริงๆว่าคุณจะได้ผลลัพธ์ที่ดีกว่าสำหรับfacแม้ว่า

ถ้าฉันคิดว่าซีพียูทำหน้าที่คำนวณแฟคทอเรียลของ 3 ได้เท่าไหร่พูดใน Python การลดจำนวนสองสามร้อยนั้นไม่ใช่เรื่องใหญ่เลย