'정렬'은 기본 아핀 로직에서 입력 할 수 있습니까?

다음의 λ 용어는 여기에서 정상적인 형태입니다.

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))

교회 인코딩 목록에 대한 정렬 알고리즘을 구현합니다. 즉, 다음의 결과입니다.

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

비슷하게,

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))))

또한 고려할 숫자에 대한 제한을 추가 인수로 제공해야한다는 점을 제외하고는 위와 동일한 목록에 대한 정렬을 구현합니다.

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

해당 용어가 기본 아핀 논리에 입력 가능한지 여부를 결정하려고합니다. 공개적으로 사용 가능한 EAL 유형 검사기를 모르기 때문에 예상보다 어려운 작업을 수행하고 있습니다. sort기본 아핀 로직에 대한 유형이 있습니까?

lo.logic lambda-calculus type-systems

— MaiaVictor
소스

"일반"유형이 있습니까? 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^-$

이 의견이 답이 될 수 있을까요?

— Andrej Bauer

질문을 읽는 동안. :-)

— Tayfun Pay

나는 sort거기에 제시된 것처럼 EAL에 입력 할 수 없다고 생각합니다. 나는 그것을 증명할 수는 없지만 오라클이 없으면 Lamping의 Abstract Algorithm에서 작동하지 않습니다. 또한이 용어는 다소 영리하고 간략하지만 EAL 친화적이지 않은 매우 엉뚱한 전략을 사용합니다.

그러나이 질문 뒤에는 " 흥미로운 분류 기능을 EAL로 구현할 수 있습니까? " 라는보다 흥미로운 질문이 있습니다 . 당시에는 매우 어려운 질문 이었지만 이제는 사소한 것 같습니다. 물론입니다. 간단한 방법이 많이 있습니다. 예를 들어 Scott 인코딩 NatSet으로 Church 인코딩 된 을 채운 Nat다음 목록으로 변환하면됩니다. 다음은 완전한 데모입니다.

-- 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])

sort위 의 약간 변경된 버전의 bruijn-indexed normal 형식은 (x -> (x x))작동하기 위해 첫 번째 인수로 받아야합니다 (그렇지 않으면 정상적인 형식이 아닙니다).

λλ(((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)

회고하면 꽤 간단합니다.

— MaiaVictor
소스