Чи вводиться `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

— MaiaVictor
джерело

Чи має він "звичайний" тип? Що станеться, якщо ви підключите його до Haskell?

— Андрій Бауер

Я згоден з Андрієм, умови нечитабельні як такі. Які алгоритми вони реалізують? Якесь ціле чисельне сортування, не засноване на порівнянні ? Яку систему набору на основі EAL ви розглядаєте? Наївна (без зменшення предмета) або Коппола, Дал Лаго та Рончі ? Чи вводяться вони в System F, наприклад,

, де

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}$

? Якщо ні, то немає сподівання, що їх можна ввести в будь-якій системі EAL.

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 до System F (або до простих типів, якщо ви не використовуєте поліморфізм), такий що якщо

(\cdot)^{-}

$(\cdot)^-$

t : A

$t:A$ в EAL, то

у системі F . Те, що працює ваш спрощений оцінювач, не суперечить цьому: те, що змушує алгоритм Лампінга працювати без дужок і круасанів, є властивістю стратифікації термінів, які суто структурні і не залежать від типів: є терміни, що не змінюються (у System F, EAL, Haskell або будь-яку іншу), які стратифіковані. Я думаю, що ваш термін повинен входити до цього класу.

t^{-} : A^{-}

$t^-:A^-$

— Даміано Мацца

Може, ці коментарі можна перетворити на відповідь?

— Андрій Бауер

Під час читання питань. :-)

— Tayfun Pay

Я думаю sort, як це представлено там, не можна вводити EAL. Я не можу цього довести, але це не працює над абстрактним алгоритмом Лампінга без оракула. Більше того, хоча цей термін дещо розумний і короткий, він використовує дуже хитрі стратегії, які не є зручними для EAL.

Але за цим питанням стоїть цікавіше: "чи може бути реалізована функція сортування нату в EAL" ? Тоді це було дуже важким питанням, але зараз це виглядає досить банально. Так, звісно. Існує багато простих способів зробити це. Наприклад, можна просто заповнити Скотта, закодованого кодом NatSetChurch 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)

Досить просто в ретроспективі.

— MaiaVictor
джерело