Là `sort` có thể đánh máy trên logic affine cơ bản?

Thuật ngữ sau đây, ở đây ở dạng bình thường:

sort = (λabc.(a(λdefg.(f(d(λhij.(j(λkl.(k(λmn.(mhi))l))
       (h(λkl.l)i)))(λhi.(i(λjk.(bd(jhk)))(bd(h(λjk.(j
       (λlm.m)k))c)))))e))(λde.e)(λde.(d(λfg.g)e))c))

Thực hiện một thuật toán sắp xếp cho các danh sách được mã hóa của nhà thờ. Đó là, kết quả của:

sort (λ c n . (c 3 (c 1 (c 2 n)))) β→ (λ c n . (c 1 (c 2 (c 3 n))))

Tương tự

sort_below = λabcd.a(λef.f(λghi.g(λj.h(λkl.kj(ikl)))(hi))e(λgh.h))
            (λe.d)(λe.b(λf.e(f(λghi.hg)(λgh.cfh))))

Cũng thực hiện sắp xếp cho các danh sách giống như trên, ngoại trừ bạn phải cung cấp một đối số bổ sung với giới hạn cho các số mà nó sẽ xem xét:

sort_below 4 [5,1,3,2,4] → [1,2,3]

Tôi đang cố gắng xác định xem các thuật ngữ đó có thể đánh máy được trên logic affine cơ bản hay không. Vì tôi không biết bất kỳ trình kiểm tra loại EAL nào có sẵn công khai, điều này chứng tỏ một nhiệm vụ khó khăn hơn tôi mong đợi. Có một loại cho sortlogic affine cơ bản?

lo.logic lambda-calculus type-systems

— MaiaVictor
nguồn

Liệu nó có một loại "bình thường"? Điều gì xảy ra nếu bạn cắm nó vào Haskell?

— Andrej Bauer

s o r t : N a t L i s t \to N a t L i s t

$sort:\mathsf{NatList}\to\mathsf{NatList}$

N a t L i s t := \forall X . (N a t \to X \to X) \to X \to X

$\mathsf{NatList}:=\forall X.(\mathsf{Nat}\to X\to X)\to X\to X$

(\cdot)^{-}

$(\cdot)^-$

t : A

$t:A$

t^{-} : A^{-}

$t^-:A^-$

Có lẽ những bình luận này có thể được biến thành một câu trả lời?

— Andrej Bauer

Trong khi đọc qua các câu hỏi. :-)

— Tayfun Trả tiền

Tôi nghĩ sort, như được trình bày ở đó, không thể đánh máy trên EAL. Tôi không thể chứng minh điều đó, nhưng nó không hoạt động trên Thuật toán trừu tượng của Lamping mà không có lời tiên tri. Hơn nữa, trong khi thuật ngữ này có phần thông minh và ngắn gọn, nó sử dụng các chiến lược rất kỳ quặc mà không thân thiện với EAL.

Nhưng đằng sau câu hỏi này còn có một câu hỏi thú vị hơn: "chức năng sắp xếp tự nhiên có thể được thực hiện trong EAL" không? Đó là một câu hỏi rất khó lúc đó, nhưng bây giờ nó trông khá tầm thường. Phải, tất nhiên. Có nhiều cách đơn giản hơn để làm điều đó. Ví dụ, người ta chỉ có thể điền mã Scott được mã hóa NatSetbằng Nats được mã hóa Church , sau đó chuyển đổi nó thành một danh sách. Đây là một minh chứng đầy đủ:

-- sort_example.mel
-- Sorting a list of Church-encoded numbers on the untyped lambda calculus
-- with terms that can be executed by Lamping's Abstract Algorithm without
-- using the Oracle. Test by calling `mel sort_example.mel`, using Caramel,
-- from https://github.com/maiavictor/caramel

-- Constructors for Church-encoded Lists 
-- Haskell: `data List = Cons a (List a) | Nil`
Cons head tail = (cons nil -> (cons head (tail cons nil)))
Nil            = (cons nil -> nil)

-- Constructors for Church-encoded Nats
-- Haskell: `data Nat = Succ Nat | Zero`
Succ pred = (succ zero -> (succ (pred succ zero)))
Zero      = (succ zero -> zero)

---- Constructors for Scott-encoded NatMaps
---- Those work like lists, where `Yep` constructors mean
---- there is a number on that index, `Nah` constructors
---- mean there isn't, and `End` ends the list.
---- Haskell: `data NatMap = Yep NatMap | Nah NatMap | End`
Yep natMap = (yep nah end -> (yep natMap))
Nah natMap = (yep nah end -> (nah natMap))
End        = (yep nah end -> end)

---- insert :: Nat (Church) -> NatMap (Scott) -> NatMap (Scott)
---- Inserts a Church-encoded Nat into a Scott-encoded NatMap.
insert nat natMap    = (nat succ zero natMap)
    succ pred natMap = (natMap yep? nah? end?)
        yep? natMap  = (Yep (pred natMap))
        nah? natMap  = (Nah (pred natMap))
        end?         = (Nah (pred natMap))
    zero natMap      = (natMap Yep Yep (Yep End))

---- toList :: NatMap (Scott) -> List Nat (Church)
---- Converts a Scott-Encoded NatMap to a Church-encoded List
toList natMap        = (go go natMap 0)
    go go natMap nat = (natMap yep? nah? end?)
        yep? natMap  = (Cons nat (go go natMap (Succ nat)))
        nah? natMap  = (go go natMap (Succ nat))
        end?         = Nil

---- sort :: List Nat (Church) -> List Nat (Church)
---- Sorts a Church-encoded list of Nats in ascending order.
sort nats = (toList (nats insert End))

-- Test
main = (sort [1,4,5,2,3])

Đây là dạng bình thường được lập chỉ mục bruijn của một phiên bản thay đổi một chút sortở trên, phải nhận (x -> (x x))làm đối số đầu tiên để hoạt động (nếu không nó không có dạng bình thường):

λλ(((1 λλλ(((1 λλλ((1 3) (((((5 5) 2) λλ(1 ((5 1) 0))) 1) 0))) 
λ(((3 3) 0) λλ(1 ((3 1) 0)))) λλ0)) ((0 λλ(((1 λλ(((0 λλλλ(2 (
5 3))) λλλλ(1 (5 3))) λλλ(1 (4 3)))) λ(((0 λλλλ(2 3)) λλλλ(2 3
)) λλλ(2 λλλ0))) 0)) λλλ0)) λλ0)

Khá đơn giản khi nhìn lại.

— MaiaVictor
nguồn