กลับมาที่นี่เกือบหนึ่งปีต่อมาฉันรู้ว่าฉันพลาดงานวิจัยที่สำคัญก่อนโพสต์
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 นำไปสู่โปรแกรมขนาดเล็กนั้นได้รับการยืนยันอย่างช้าๆเมื่อโปรแกรมของฉันเรียนรู้ฟังก์ชั่นที่เรียบง่ายเขียนพวกมันแล้วเรียนรู้หน้าที่ที่ใหญ่ขึ้นจากเพดานที่ดีขึ้น