`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

— Andrej Bauer

ฉันเห็นด้วยกับ Andrej เงื่อนไขไม่สามารถอ่านได้เช่นนี้ พวกเขาใช้อัลกอริทึมอะไร การเรียงลำดับจำนวนเต็มบางอย่างไม่ได้ขึ้นอยู่กับการเปรียบเทียบ ? คุณกำลังพิจารณาเรื่องระบบการพิมพ์แบบ EAL อะไร? คนที่ไร้เดียงสา (ไม่มีการลดหัวเรื่อง) หรือหนึ่งโดยCoppola, Dal Lago และ Ronchi ? พวกเขา typable ในระบบ 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$

— Damiano Mazza

ใช่นี่เป็นเพราะมี functor ที่หลงลืม

จาก EAL ถึง System F (หรือประเภทที่เรียบง่ายหากคุณไม่ใช้ polymorphism) เช่นถ้า

ใน EAL ดังนั้น

ใน System F ความจริงที่ว่าผู้ประเมินที่ง่ายของคุณทำงานไม่สอดคล้องกับสิ่งนี้: อะไรที่ทำให้อัลกอรึทึมของ Lamping ทำงานโดยไม่ต้องใช้วงเล็บและครัวซองต์เป็นคุณสมบัติการแบ่งชั้นของคำศัพท์ซึ่งมีโครงสร้างแบบหมดจดและเป็นอิสระ Haskell หรืออะไรก็ตาม) ซึ่งแบ่งเป็นชั้น ๆ ฉันเดาว่าเทอมของคุณจะต้องตกในคลาสนี้

(\cdot)^{-}

$(\cdot)^-$

t : A

$t:A$

t^{-} : A^{-}

$t^-:A^-$

— Damiano Mazza

ความคิดเห็นเหล่านี้อาจกลายเป็นคำตอบได้ไหม?

— Andrej Bauer

ในขณะที่อ่านคำถาม :-)

— Tayfun จ่าย

ฉันคิดว่าsortดังที่แสดงไว้ไม่สามารถพิมพ์ได้บน EAL ฉันไม่สามารถพิสูจน์ได้ แต่มันไม่สามารถใช้ได้กับอัลกอริธึมบทคัดย่อของ Lamping โดยไม่ต้องใช้คำพยากรณ์ ยิ่งกว่านั้นในขณะที่คำศัพท์ค่อนข้างฉลาดและสั้น แต่ก็ใช้กลยุทธ์ที่แปลกประหลาดมากซึ่งไม่เป็นมิตรกับ EAL

แต่เบื้องหลังคำถามนี้มีสิ่งที่น่าสนใจมากกว่านี้: "สามารถใช้ฟังก์ชันการเรียงลำดับ nat ใน EAL ได้หรือไม่" นั่นเป็นคำถามที่ยากมากในตอนนั้น แต่ตอนนี้มันดูน่าสนใจเล็กน้อย ใช่แน่นอน มีหลายวิธีที่ง่ายกว่าในการทำ ตัวอย่างเช่นเราสามารถเติมสก็อตที่เข้ารหัสNatSetด้วยคริสตจักรที่เข้ารหัส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
แหล่งที่มา