Aff বাছাই aff প্রাথমিক affine যুক্তি টাইপযোগ্য?

নিম্নোক্ত term-মেয়াদ, এখানে সাধারণ আকারে:

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]

আমি শর্তাবলী প্রাথমিক affine যুক্তি টাইপযোগ্য কিনা তা নির্ধারণ করার চেষ্টা করছি। যেহেতু আমি প্রকাশিত কোনও EAL টাইপ-চেকার জানি না, এটি আমার প্রত্যাশার চেয়ে কঠিন কাজ প্রমাণ করছে task sortপ্রাথমিক affine যুক্তি জন্য একটি টাইপ আছে ?

lo.logic lambda-calculus type-systems

— MaiaVictor
সূত্র

এটিতে কি "সাধারণ" টাইপ রয়েছে? আপনি যদি এটি হ্যাসকেলে প্লাগ করেন তবে কি হবে?

— আন্দ্রেজ বাউর

আমি আন্দ্রেজের সাথে একমত, পদগুলি যেমন অপঠনযোগ্য। তারা কোন অ্যালগরিদমগুলি প্রয়োগ করে? কিছু পূর্ণসংখ্যার বাছাই করা তুলনার ভিত্তিতে নয় ? EAL- ভিত্তিক কোন টাইপিং সিস্টেমটি আপনি বিবেচনা করছেন? নিষ্পাপ এক (কোনও বিষয় হ্রাস নয়) বা কোপপোলা, ডাল লাগো এবং রনচির একটি ? তারা সিস্টেম এফ, যেমন মধ্যে typable করছেন

, যেখানে

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$

— দামিয়ানো মাজাজা

হ্যাঁ, এই একটি ভুলো functor কারণ নেই

EAL থেকে সিস্টেম এফ (বা সহজ ধরনের জন্য, আপনাকে পলিমরফিজম ব্যবহার করবেন না যদি) যেমন যে যদি

EAL করুন, তারপরে

সিস্টেম এফ মধ্যে । আপনার সরলিকৃত মূল্যায়নকারী এটির সাথে বেমানান নয়: বন্ধনী এবং ক্রাইসেন্টগুলি ছাড়াই ল্যাম্পিংয়ের অ্যালগরিদম কাজকে শর্তাদির একটি স্তরসমষ্টির সম্পত্তি, যা খাঁটি কাঠামোগত এবং প্রকারভেদে স্বতন্ত্র: সেখানে অক্ষম শর্তাদি রয়েছে (সিস্টেম এফ, EAL, হাস্কেল বা যাই হোক না কেন) যা স্তরযুক্ত। আমার ধারণা আপনার শব্দটি অবশ্যই এই শ্রেণিতে পড়বে।

(\cdot)^{-}

$(\cdot)^-$

t : A

$t:A$

t^{-} : A^{-}

$t^-:A^-$

— দামিয়ানো মাজাজা

এই মন্তব্যগুলি একটি উত্তর পরিণত হতে পারে?

— আন্দ্রেজ বাউয়ার

প্রশ্নের মাধ্যমে পড়ার সময়। :-)

— তাইফুন

আমি মনে করি sort, যেমন এখানে উপস্থাপন করা হয়েছে, EAL তে টাইপযোগ্য নয়। আমি এটি প্রমাণ করতে পারি না, তবে এটি ওরাকল ছাড়া ল্যাম্পিংয়ের অ্যাবস্ট্রাক্ট অ্যালগরিদমে কাজ করে না। তদ্ব্যতীত, শব্দটি কিছুটা চালাক এবং সংক্ষিপ্ত হলেও এটি খুব ঘৃণ্য কৌশলগুলি ব্যবহার করে যা 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])

এখানে 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
সূত্র