คู่พื้นฐานของ combinator ที่สมบูรณ์แบบที่สุดสำหรับการแสดงผลแบบแบน


9

ในกระดาษของ Chris Okasaki " Flattening Combinators: Surviving Without วงเล็บ) " เขาแสดงให้เห็นว่ามีสอง combinators เพียงพอและจำเป็นสำหรับการเข้ารหัสนิพจน์ทัวริงที่สมบูรณ์โดยไม่จำเป็นต้องใช้ตัวดำเนินการหรือวงเล็บ

เมื่อเทียบกับการเข้ารหัสของ combinatory ตรรกะของ John Trump ใน " Binary Lambda แคลคูลัสและ Combinatory Logic " ผ่านการเข้ารหัสคำนำหน้า S และ K combinators กับผู้ให้บริการแอปพลิเคชันเพียงต้องการ combinators สองตัวสำหรับการแสดงแบบแบนเพิ่มความหนาแน่นของรหัส ผลลัพธ์ของการกำหนดหมายเลข Goedel จะจับคู่ทุกจำนวนเต็มกับนิพจน์ระยะปิดที่มีรูปแบบที่ถูกต้องซึ่งแตกต่างจาก esolangs ที่มีความยาวแคลคูลัสและคำอธิบายน้อยที่สุดซึ่งตัวแทนที่เป็นที่ยอมรับทั่วไปมักอนุญาตให้คำอธิบายโปรแกรมที่ไม่ถูกต้อง

อย่างไรก็ตามการเข้ารหัสของ Okasaki นั้นมีประโยชน์มากที่สุดในการทำแผนที่ทางเดียวจากคำศัพท์ lambda แคลคูลัสกับ bitstrings ไม่จำเป็นต้องเป็นวิธีอื่น ๆ เนื่องจาก combinators สองตัวที่ใช้ในการลดนี้ค่อนข้างซับซ้อนเมื่อใช้เป็นคำแนะนำในการทดแทนที่ใช้งานได้จริง

คู่พื้นฐานของ combinator ที่สมบูรณ์แบบที่สุดที่ไม่ต้องการตัวดำเนินการแอปพลิเคชันคืออะไร


1
ไม่แน่ใจว่าเกี่ยวข้องหรือไม่ แต่: โปรดทราบว่ามีฐานของแคลคูลัสแลมบ์ดาที่เกิดจากคำเดียว สิ่งนี้ทำให้การคำนวณหมายเลขGödelง่ายขึ้น cs.uu.nl/research/techreps/repo/CS-1989/1989-14.pdf
ไค

คำตอบ:


2

กลับมาที่นี่เกือบหนึ่งปีต่อมาฉันรู้ว่าฉันพลาดงานวิจัยที่สำคัญก่อนโพสต์

Jotดูเหมือนจะพอดีกับสิ่งที่ฉันขอด้วยผู้ประสานงาน B & X สองคนที่ค่อนข้างง่ายซึ่งสามารถแสดงด้วยหมายเลข Goedel ขนาดกะทัดรัด

ฉันทำให้การอ้างอิงของเขาง่ายขึ้นด้วย Python:

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 ของมัน

B (เทียบเท่ากับการเข้ารหัสคูณด้วยคริสตจักร) ทำหน้าที่ฟังก์ชั่นการใช้งาน (วงเล็บ) และสามารถแยกครึ่ง S / K ของ Iota combinator X แบบพื้นฐานเดียว

มีคุณสมบัติที่สำคัญบางประการของภาษานี้ที่ฉัน (เกือบ) ไร้ยางอายขโมยจากเว็บไซต์ของนักประดิษฐ์ของ Chris Barker ประมาณปี 2000

Jot เป็นภาษาปกติในรูปแบบไวยากรณ์ แต่ทัวริงสมบูรณ์ คุณสามารถเห็นได้จากการใช้งาน J (n) ว่าหากภาษาโฮสต์รองรับการเรียกซ้ำแบบหางไม่จำเป็นต้องใช้พื้นที่สแต็กเพื่อแยกวิเคราะห์รูปแบบโปรแกรม bitstring

การพิสูจน์ความสมบูรณ์ของทัวริงมาจากไซต์ของ Chris เช่นกันโดยใช้ตรรกะ combinatory ทัวริงที่เป็นที่รู้จักกันอยู่แล้วโดยใช้ตัวรวม S และ K:

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

Jot ไม่มีข้อผิดพลาดทางไวยากรณ์ทุกโปรแกรมที่กำหนดหมายเลข Goedel n เป็นโปรแกรมที่ถูกต้อง นี่อาจเป็นสิ่งสำคัญที่สุดในการวิจัยของฉันเพราะมันไม่เพียง แต่ทำให้การแยกวิเคราะห์ง่ายขึ้นเล็กน้อย แต่ในทางทฤษฎีควรทำให้ Jot มีความสำคัญมากกว่าการเข้ารหัสแบบทัวริงที่ต้องข้ามโปรแกรมที่มีรูปแบบไม่สมบูรณ์

ฉันได้เขียนเครื่องมือสองสามอย่างเพื่อ 'แก้ปัญหา' โดยใช้กำลังดุร้ายปัญหากึ่งตัดสินใจได้ในการค้นหาความซับซ้อนของฟังก์ชัน Kolmogorov ใน Jot มันทำงานโดยอาศัยโปรแกรมเมอร์ที่จะระบุตัวอย่างการฝึกอบรมที่มีลักษณะเฉพาะบางอย่างของฟังก์ชั่นของฟังก์ชั่นแล้วแจกแจงโปรแกรม Jot ทั้งหมดจนกว่าตัวอย่างการฝึกอบรมทั้งหมดจะถูกจับคู่และสุดท้ายพยายามพิสูจน์ความเท่าเทียมกันของฟังก์ชั่น

ปัจจุบันใช้งานได้กับ ~ 40 บิตกับทรัพยากรที่ จำกัด ของฉันเท่านั้น ฉันพยายามเขียนใหม่ด้วยตัวแก้ SAT เพื่อเรียนรู้โปรแกรมที่มีขนาดใหญ่กว่ามาก ถ้าคุณรู้ว่าวิธีการคายล้อมรอบปิดที่ซ้อนกันเป็นสูตรบูลโปรดช่วยฉันออกมาพร้อมกับคำถามใหม่

ตอนนี้สำหรับการเปรียบเทียบที่น่าสนใจกับ Binary แลมบ์ดาแคลคูลัสของ John Tromp ซึ่งเป็นที่รู้จักกันดีว่ามีความรัดกุม แต่มีปัญหาข้อผิดพลาดทางไวยากรณ์ที่เป็นไปได้ โปรแกรมต่อไปนี้สร้างขึ้นโดยโปรแกรมการเรียนรู้ของฉันในไม่กี่วินาที

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

จากการทดลองของฉันเองสมมติฐานที่ Jot นำไปสู่โปรแกรมขนาดเล็กนั้นได้รับการยืนยันอย่างช้าๆเมื่อโปรแกรมของฉันเรียนรู้ฟังก์ชั่นที่เรียบง่ายเขียนพวกมันแล้วเรียนรู้หน้าที่ที่ใหญ่ขึ้นจากเพดานที่ดีขึ้น

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.