基本的なアフィンロジックで「並べ替え」を入力できますか？

次のλ項、ここでは通常の形式：

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

— マイアビクター
ソース

「通常の」タイプはありますか？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

私が考えるsortEALにtypeableではない、そこに提示され、。それを証明することはできませんが、オラクルなしでは、Lampingの抽象アルゴリズムでは機能しません。さらに、この用語は多少巧妙で簡潔ですが、EALに適さない非常に奇抜な戦略を使用しています。

しかし、この質問の背後にはもっと興味深い問題があります。「natソート機能をEALに実装できるか」ということです。それは当時非常に困難な質問でしたが、今では非常に簡単に見えます。はい、もちろん。それを行うには、もっと簡単な方法がたくさんあります。例として、スコットエンコードさNatSetれたチャーチエンコードされたNatsを入力し、それをリストに変換するだけです。ここに完全なデモンストレーションがあります：

-- 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これは、上記のわずかに変更されたバージョンのbrijn-indexed正規形です。これは(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)

振り返ってみるとかなり単純です。

— マイアビクター
ソース