可以在基本仿射逻辑上键入“ sort”吗？

以下λ项，此处为标准形式：

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

— 玛雅·维克多
source

它是否具有“普通”类型？如果将其插入Haskell，会发生什么？

— 安德烈·鲍尔

我同意安德烈（Andrej）的观点，因此无法理解。它们实现什么算法？一些不基于比较的整数排序？您正在考虑使用哪种基于EAL的打字系统？天真的一个（没有主题还原）还是科波拉，达拉戈和罗奇的一个？它们是否在系统F中可，例如，其中？如果没有，那么就没有希望它们可以在任何基于EAL的系统中键入。

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$

— 达米亚诺·马扎

是的，这是因为从EAL到系统F（或简单类型，如果您不使用多态性）有一个健忘的函子，使得如果EAL中的，则在系统F中。简化的评估程序有效的事实与此并不矛盾：使Lamping的算法在没有括号和牛角面包的情况下工作的原因是术语的分层属性，它纯粹是结构性的，并且与类型无关：在系统中存在不可分的术语F，EAL，Haskell或其他）。我想你的学期一定属于这一类。

(\cdot)^{-}

$(\cdot)^-$

t : A

$t:A$

t^{-} : A^{-}

$t^-:A^-$

— 达米亚诺·马扎

也许这些评论可以变成答案？

— 安德烈·鲍尔

在阅读问题时。:-)

— Tayfun Pay'7

我认为sort，如此处所述，不能在EAL上键入。我无法证明这一点，但是如果没有oracle，它就不适用于Lamping的Abstract Algorithm。而且，尽管该术语有些巧妙和简短，但它使用了非常古怪的策略，对EAL不友好。

但是，在这个问题后面还有一个更有趣的问题：“可以在EAL中实现nat-sorting函数”吗？当时这是一个非常棘手的问题，但是现在看起来非常琐碎。当然是。有许多更简单的方法可以做到这一点。举一个例子，可以NatSet用Church-encoded 填充Scott 编码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])

这是上述内容的稍有改动的版本的以bruijn索引的普通形式sort，必须使用它(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)

回想起来很简单。

— 玛雅·维克多
source