Neredeyse bir yıl sonra bu konuya dönersek, yayınlamadan önce bazı kritik araştırmaları kaçırdığımı fark ettim.
Jot , kompakt bir Goedel numaralandırmasıyla temsil edilebilecek iki nispeten basit birleştirici B & X ile istediğim şeyin faturasına uyuyor gibi görünüyor.
Python ile referans uygulamasını basitleştirdim:
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 numarası n ile temsil edilen programı gösteren yerleşik işlevi döndürür.
B (Kilise kodlu çarpmaya eşdeğer), işlevsel uygulama (parantez) işlevini yerine getirir ve tek temelli Iota birleştiricisinin X / S yarımlarını izole edebilir.
Bu dilin, neredeyse 2000 yılındaki dilin mucidi Chris Barker'ın web sitesinden utanmadan çaldığım birkaç önemli özelliği var.
Jot sözdiziminde normal bir dildir ancak Turing-complete. J (n) uygulamasından, bir ana bilgisayar dili kuyruk yinelemeyi destekliyorsa, bit dizisi program biçimini ayrıştırmak için yığın alanı gerekmediğini görebilirsiniz.
Turing-tamamının kanıtı, Chris'in sitesinden de geliyor ve S ve K birleştiricileri kullanarak zaten bilinen Turing-complete kombine mantığını uyguluyor:
K ==> 11100
S ==> 11111000
AB ==> 1[A][B], where A & B are arbitrary CL combinators built up from K & S
Jot'un sözdizimi hatası yoktur, Goedel n numarası verilen her program geçerli bir programdır. Bu muhtemelen kendi araştırmamın en önemli yönüdür, çünkü sadece önemsizliğe ayrışmayı kolaylaştırmakla kalmaz, aynı zamanda teorik olarak Jot'u, hatalı biçimlendirilmiş programları atlaması gereken herhangi bir Turing-tamam kodlamasından çok daha cimri yapmalıdır.
Bir fonksiyonun Jot'taki Kolmogorov karmaşıklığını bulmada yarı kararlı bir problemi kaba kuvvetle çözmek için birkaç araç yazdım. Bir fonksiyonun eşleştirilmesinin çok karakteristik bazı eğitim örneklerini belirtmek için programcıya güvenerek çalışır, daha sonra tüm eğitim örnekleri eşleşene kadar tüm Jot programlarını numaralandırır ve son olarak bulunan bir fonksiyonun orijinal ayrıntılı uygulama ile eşitliğini kanıtlamaya çalışır.
Şu anda sadece sınırlı kaynaklarla ~ 40 bit'e kadar çalışıyor. Çok daha büyük programlar öğrenmek için bir SAT çözücü ile yeniden yazma girişiminde bulunuyorum. Sınırlı iç içe geçmiş kapakların boolean formülü olarak nasıl açılacağını biliyorsanız, lütfen yeni soruma yardımcı olun .
Şimdi, John Tromp'un kısaca bilinen, ancak olası sözdizimi hataları sorununa sahip olan Binary Lambda Calculus ile bazı ilginç karşılaştırmalar için. Aşağıdaki programlar öğrenme programım tarafından birkaç saniye içinde oluşturuldu.
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
Kendi deneylerimden, Jot'un daha küçük programlara yol açtığı hipotezi, programım basit işlevleri öğrendikçe, bunları oluşturduktan, daha sonra gelişmiş tavandan daha büyük işlevleri öğrendiğinden yavaş yavaş doğrulanıyor.