Trở lại vấn đề này gần một năm sau, tôi nhận ra mình đã bỏ lỡ một số nghiên cứu quan trọng trước khi đăng.
Jot dường như phù hợp với hóa đơn của những gì tôi đã yêu cầu, với hai tổ hợp B & X tương đối đơn giản có thể được biểu thị bằng cách đánh số Goedel nhỏ gọn.
Tôi đã đơn giản hóa việc triển khai tham chiếu của mình với 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) trả về hàm dựng sẵn biểu thị chương trình được biểu thị bằng số Goedel n của nó.
B (tương đương với mã hóa nhân của Church) phục vụ chức năng của ứng dụng chức năng (dấu ngoặc đơn) và có thể cách ly nửa S / K của bộ kết hợp Iota X cơ sở đơn.
Có một vài tính chất quan trọng của ngôn ngữ này mà tôi (gần như) không biết xấu hổ ăn cắp từ trang web của nhà phát minh ngôn ngữ Chris Barker, khoảng năm 2000.
Jot là một ngôn ngữ thông thường theo cú pháp nhưng Turing-Complete. Bạn có thể thấy từ việc triển khai J (n) rằng nếu một ngôn ngữ máy chủ hỗ trợ đệ quy đuôi, thì không có không gian ngăn xếp cần thiết để phân tích định dạng chương trình chuỗi bit.
Bằng chứng về tính đầy đủ của Turing cũng xuất phát từ trang web của Chris, thực hiện logic kết hợp hoàn chỉnh Turing đã biết bằng cách sử dụng các tổ hợp S và K:
K ==> 11100
S ==> 11111000
AB ==> 1[A][B], where A & B are arbitrary CL combinators built up from K & S
Jot không có lỗi cú pháp, mọi chương trình được cung cấp số Goedel n của nó là một chương trình hợp lệ. Đây có lẽ là khía cạnh quan trọng nhất đối với nghiên cứu của riêng tôi, vì nó không chỉ đơn giản hóa việc phân tích cú pháp thành tầm thường, mà về mặt lý thuyết cũng khiến Jot trở nên khó hiểu hơn bất kỳ mã hóa hoàn chỉnh Turing nào phải bỏ qua các chương trình không đúng định dạng.
Tôi đã viết một vài công cụ để 'giải quyết' thông qua vũ lực, vấn đề bán quyết định trong việc tìm kiếm độ phức tạp Kolmogorov của hàm trong Jot. Nó hoạt động bằng cách dựa vào lập trình viên để xác định một số ví dụ đào tạo rất đặc trưng của ánh xạ hàm, sau đó liệt kê tất cả các chương trình Jot cho đến khi tất cả các ví dụ đào tạo được khớp, và cuối cùng cố gắng chứng minh tính bằng nhau của hàm tìm thấy với triển khai verbose ban đầu.
Hiện tại nó chỉ hoạt động tối đa ~ 40 bit với tài nguyên giới hạn của tôi. Tôi đang cố gắng viết lại với một người giải SAT để học các chương trình lớn hơn nhiều. Nếu bạn biết làm thế nào để hủy bỏ các đóng cửa lồng nhau như một công thức boolean, xin vui lòng giúp đỡ với câu hỏi mới của tôi .
Bây giờ đối với một số so sánh thú vị với Binary Lambda Compus của John Tromp, được biết đến với tính đơn giản, nhưng có vấn đề về lỗi cú pháp có thể xảy ra. Các chương trình sau được tạo bởi chương trình học của tôi trong vài giây.
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
Từ các thí nghiệm của riêng tôi, giả thuyết rằng Jot dẫn đến các chương trình nhỏ hơn đang dần được xác nhận khi chương trình của tôi học các hàm đơn giản, kết hợp chúng, sau đó học các hàm lớn hơn từ trần cải tiến.