Máy phát điện tính toán Lambda

Tôi không biết nơi nào khác để hỏi câu hỏi này, tôi hy vọng đây là một nơi tốt.

Tôi chỉ tò mò muốn biết liệu có thể tạo ra máy tính lambda không; về cơ bản, một vòng lặp sẽ, trong thời gian vô hạn, tạo ra mọi hàm tính toán lambda có thể. (giống như ở dạng chuỗi).

Vì phép tính lambda rất đơn giản, chỉ có một vài yếu tố theo ký hiệu của nó, tôi nghĩ rằng có thể (mặc dù, không hữu ích lắm) để tạo ra tất cả các kết hợp có thể có của các yếu tố ký hiệu đó, bắt đầu bằng các kết hợp đơn giản nhất, và do đó tạo ra mọi lambda có thể hàm tính toán.

Tất nhiên, tôi gần như không biết gì về tính toán lambda vì vậy tôi không biết liệu điều này có thực sự khả thi hay không.

Là nó? Nếu vậy, nó khá đơn giản như tôi đã hình dung ra, hoặc về mặt kỹ thuật là có thể, nhưng khó đến mức nó thực sự không thể?

Tái bút Tôi không nói về các hàm giảm beta, tôi chỉ nói về mọi ký hiệu hợp lệ của mọi hàm tính toán lambda.

Chắc chắn, đây là một bài tập mã hóa tiêu chuẩn.

Trước hết, hãy để bất kỳ hàm tính toán tính toán nào, được gọi là hàm ghép nối. Một lựa chọn tiêu chuẩn là$p : \mathbb N^2 \to \mathbb N$

Người ta có thể chứng minh rằng đây là một mệnh đề, do đó, với bất kỳ tự nhiên nào , chúng ta có thể tính n , m sao cho p ( n , m ) = k .$k$$n,m$$p(n,m)=k$

Với các điều khoản lambda enumerate, sửa chữa bất kỳ liệt kê các tên biến: .$x_0,x_1,x_2,\ldots$

Sau đó, với mỗi số tự nhiên , in l a m b d a ( i ) , được định nghĩa đệ quy như sau:$i$$lambda(i)$

• nếu chẵn, hãy để j = i / 2 và trả về biến x $i$$j=i/2$$x_j$
• nếu là số lẻ, hãy để j = ( i - 1 ) /$i$$j=(i-1)/2$
  • nếu là chẵn, hãy để k = j / 2 và tìm n , m sao cho p ( n , m ) = k ; tính N = l a m b d a ( n ) , M = l a m b d a ( m ) ; ứng dụng trả lại ( N M $j$$k=j/2$$n,m$$p(n,m)=k$$N=lambda(n), M=lambda(m)$$(NM)$
  • nếu là số lẻ, hãy để k = ( j - 1 ) / 2 và tìm n , m sao cho p ( n , m ) = k ; tính M = l a m b d a ( m ) ; trở trừu tượng ( λ x n . M $j$$k=(j-1)/2$$n,m$$p(n,m)=k$$M=lambda(m)$$(\lambda x_n.\ M)$

Chương trình này được chứng minh bởi các song ánh sau "đại số" liên quan đến các thiết lập của tất cả các điều khoản lambda :$\Lambda$

được đọc là "các thuật ngữ lambda, về mặt cú pháp, là sự kết hợp rời rạc của 1) biến (được biểu diễn dưới dạng tự nhiên), 2) ứng dụng (được tạo bởi hai thuật ngữ lambda) và 3) trừu tượng (một biến cặp / tự nhiên + thuật ngữ lambda ) ".

$\mathbb N^2 \simeq \mathbb N$$p$$\mathbb N + \mathbb N \simeq \mathbb N$

Quy trình này là chung và sẽ hoạt động trên hầu hết mọi ngôn ngữ được tạo thông qua ngữ pháp không ngữ cảnh, sẽ cung cấp một sự đồng hình tương tự như ngôn ngữ trên.

Đúng. Lấy một cái gì đó liệt kê tất cả các chuỗi ASCII có thể. Đối với mỗi đầu ra, kiểm tra xem đó có phải là cú pháp tính toán lambda hợp lệ xác định hàm không; nếu không, bỏ qua nó (Kiểm tra đó có thể được thực hiện.) Điều đó liệt kê tất cả các hàm tính toán lambda.

Như đã đề cập, đây chỉ là liệt kê các thuật ngữ từ một ngôn ngữ tự do ngữ cảnh, vì vậy chắc chắn có thể thực hiện được. Nhưng có nhiều toán học thú vị hơn đằng sau nó, đi sâu vào lĩnh vực tổ hợp anlytical.

Bài viết Đếm và tạo các thuật ngữ trong phép tính lambda nhị phân chứa một cách xử lý vấn đề liệt kê, và nhiều hơn nữa. Để làm cho mọi thứ đơn giản hơn, họ sử dụng một cái gì đó gọi là lambda calulus nhị phân , đây chỉ là một mã hóa các thuật ngữ lambda sử dụng các chỉ số De Bruijn , vì vậy bạn không phải đặt tên biến.

Bài báo đó cũng chứa mã Haskell cụ thể thực hiện thuật toán tạo của chúng. Nó chắc chắn có hiệu quả có thể.

Tôi tình cờ đã viết một triển khai phương pháp của họ ở Julia.

Chắc chắn rồi. Chúng ta có thể trực tiếp tạo ra chúng theo định nghĩa của các điều khoản lambda.

Trong Haskell, chúng tôi xác định loại đầu tiên,

data LC a = Var a | App (LC a) (LC a) | Lam a (LC a)

instance Show a => Show (LC a) where
    show (Var i)   = [c | c <- show i, c /= '\'']
    show (App m n) = "(" ++ show m ++ " " ++ show n ++ ")"
    show (Lam v b) = "(^" ++ show (Var v) ++ "." ++ show b ++ ")"

và sau đó với

lambda :: [a] -> [LC a]
lambda vars = terms 
  where
  terms = fjoin [ map Var vars ,
                  fjoin [[App t s | t <- terms] | s <- terms] ,
                  fjoin [[Lam v s | v <- vars ] | s <- terms] ]

  fjoin :: [[a]] -> [a]
  fjoin xs = go (take 1 xs) (drop 1 xs)      -- fair join
      where 
      go [] [] = []
      go a  b  = reverse (concatMap (take 1) a) ++ go 
                     (take 1 b ++ [t | (_:t) <- a]) (drop 1 b)

chúng tôi chỉ liệt kê chúng, ví dụ như

> take 20 $ lambda "xyz"
[x,y,(x x),z,(y x),(^x.x),(x y),(^y.x),((x x) x),(^x.y),(y y),(^z.x),(x (x x)),
 (^y.y),(z x),(^x.(x x)),((x x) y),(^z.y),(y (x x)),(^y.(x x))]

> take 5 $ drop 960 $ lambda "xyz"
[(((x x) y) (z x)),(^y.(^x.((x x) (x x)))),((^x.(x x)) (^x.(x x))),(^x.((^z.x) y
)),((z x) ((x x) y))]

$\Omega = (\lambda x . xx)( \lambda x . xx )$

fjointương đương với Omega đơn nguyên 's diagonal.

Tôi đã bắt gặp một công cụ trực tuyến có thể tạo các chuỗi mẫu từ một biểu thức thông thường: https : //www.brows Muff.com/tools/text-from-regex . Bạn có thể tạo rất nhiều thuật ngữ lambda mẫu bằng cách nhập một cái gì đó như thế này:

(\( (lambda \w\. )* \w+ \))* 

Tất nhiên để có được các thuật ngữ với các mức lồng nhau tùy ý, bạn sẽ cần sử dụng một ngữ pháp không ngữ cảnh, đây là một công cụ mô tả để xác định ngôn ngữ hơn một biểu thức thông thường. Tôi chưa bắt gặp một công cụ hiện có để tạo các câu ngôn ngữ mẫu dựa trên định nghĩa ngữ pháp không ngữ cảnh, nhưng không có lý do nào người ta không thể xây dựng.