คำถามติดแท็ก type-systems

3
พิมพ์คลาส vs วัตถุอินเตอร์เฟส
ฉันไม่คิดว่าฉันเข้าใจคลาสประเภท ฉันได้อ่านที่ไหนสักแห่งที่คิดว่า class classes เป็น "interfaces" (จาก OO) ที่การใช้งานประเภทนั้นผิดและทำให้เข้าใจผิด ปัญหาคือฉันมีปัญหาที่เห็นพวกเขาเป็นสิ่งที่แตกต่างและวิธีการที่ผิด ตัวอย่างเช่นถ้าฉันมีคลาสประเภท (ในไวยากรณ์ Haskell) class Functor f where fmap :: (a -> b) -> f a -> f b มันแตกต่างจากอินเตอร์เฟส [1] อย่างไร (ในไวยากรณ์ Java) interface Functor<A> { <B> Functor<B> fmap(Function<B, A> fn) } interface Function<Return, Argument> { Return apply(Argument arg); } …
2
คุณจะได้รับแคลคูลัสของสิ่งก่อสร้างจากจุดอื่น ๆ ในแลมบ์ดาคิวบ์ได้อย่างไร
CoC กล่าวกันว่าเป็นสุดยอดของทั้งสามมิติของแลมบ์ดาคิวบ์ สิ่งนี้ไม่ชัดเจนสำหรับฉันเลย ฉันคิดว่าฉันเข้าใจมิติของแต่ละบุคคลและการรวมกันของสองใด ๆ ที่ดูเหมือนจะส่งผลให้มีการรวมกันค่อนข้างตรงไปตรงมา (บางทีฉันอาจจะขาดอะไรบางอย่าง?) แต่เมื่อฉันดู CoC แทนที่จะมองเหมือนการรวมกันของทั้งสามดูเหมือนว่าสิ่งที่แตกต่างอย่างสิ้นเชิง มิติข้อมูลประเภทใดชนิดหนึ่ง Prop และขนาดเล็ก / ขนาดใหญ่มาจากไหน ผลิตภัณฑ์ที่ขึ้นต่อกันหายไปที่ไหน และทำไมจึงให้ความสำคัญกับข้อเสนอและบทพิสูจน์แทนประเภทและโปรแกรม มีสิ่งที่เทียบเท่าที่เน้นประเภทและโปรแกรมหรือไม่ แก้ไข: ในกรณีที่ไม่ชัดเจนฉันขอคำอธิบายว่า CoC เทียบเท่ากับการรวมกลุ่มของแลมบ์ดาคิวบ์อย่างตรงไปตรงมาได้อย่างไร และมีสหภาพที่แท้จริงของทั้งสามออกจากที่นั่นฉันสามารถเรียน (ที่เป็นในรูปแบบของโปรแกรมและประเภทไม่ใช่หลักฐานและข้อเสนอ)? นี่คือการตอบสนองต่อความคิดเห็นในคำถามไม่ใช่คำตอบปัจจุบัน
2
ทฤษฎีประเภท Homotopy ส่วนใดที่ไม่สามารถทำได้ใน Agda หรือ Coq
เมื่อเราดูหนังสือทฤษฎีประเภท Homotopy - เราจะเห็นหัวข้อต่อไปนี้: Homotopy type theory 2.1 Types are higher groupoids 2.2 Functions are functors 2.3 Type families are fibrations 2.4 Homotopies and equivalences 2.5 The higher groupoid structure of type formers 2.6 Cartesian product types 2.7 S-types 2.8 The unit type 2.9 P-types and the function extensionality axiom …
4
Parametricity ที่ไม่ดีเทียบกับไบนารีของพารามิเตอร์
เมื่อไม่นานมานี้ฉันสนใจเรื่องพาราเมตริกหลังจากเห็นกระดาษ LICS 2012 ของ Bernardy และ Moulin ( https://dl.acm.org/citation.cfm?id=2359499 ) ในบทความนี้พวกเขาปรับพารามิเตอร์ภายในแบบเอกภาพในระบบชนิดบริสุทธิ์ที่มีชนิดที่ขึ้นต่อกันและบอกใบ้ถึงวิธีการที่คุณสามารถขยายการก่อสร้างไปสู่สิ่งที่ต้องการโดยพลการ ฉันเคยเห็นพารามิเตอร์เลขฐานสองที่กำหนดไว้ก่อนหน้าเท่านั้น คำถามของฉันคืออะไรตัวอย่างของทฤษฎีบทที่น่าสนใจที่สามารถพิสูจน์ได้โดยใช้เลขฐานสองเป็นเลขคู่ แต่ไม่ใช่กับสมการเชิงอนุพันธ์ มันน่าสนใจที่จะเห็นตัวอย่างของทฤษฎีบทที่พิสูจน์ด้วยพารามิเตอร์ระดับตติยภูมิ แต่ไม่ใช่ด้วยระบบเลขฐานสอง (แม้ว่าฉันเคยเห็นหลักฐานว่า n-parametricity เทียบเท่ากับ n> = 2: ดูhttp: //www.sato.kuis .kyoto-u.ac.jp / ~ takeuti / art / par-tlca.ps.gz )
1
การสืบทอดนั้นแตกต่างจากการพิมพ์ย่อยอย่างไร
ในมุมมองภาษาการเขียนโปรแกรมการพิมพ์ย่อยหมายถึงอะไร ฉันได้ยินมาว่า "มรดกไม่ใช่การพิมพ์ย่อย" แล้วความแตกต่างระหว่างการสืบทอดและการพิมพ์ย่อยคืออะไร
1
คำอธิบายทางคณิตศาสตร์ (หมวดหมู่) ของคลาสประเภท
ภาษาฟังก์ชั่นสามารถดูได้เป็นหมวดหมู่ที่วัตถุเป็นประเภทและ morphisms ทำงานระหว่างพวกเขา จะทำอย่างไรเรียนชนิดใส่ในรูปแบบนี้? ฉันคิดว่าเราควรพิจารณาการใช้งานเหล่านั้นตามข้อ จำกัด ที่คลาสประเภทส่วนใหญ่มี แต่ไม่ได้แสดงใน Haskell ตัวอย่างเช่นเราควรพิจารณาเฉพาะการใช้งานของผู้Functorที่และfmap id ≡ idfmap f . fmap g ≡ fmap (f . g) หรือมีรากฐานทางทฤษฎีอื่น ๆ สำหรับการเรียนประเภท (เช่นตามพิมพ์แลมบ์ดานิ)?
2
คอมไพเลอร์สำหรับประเภทที่ขึ้นต่อกันนั้นหนักกว่าผู้บุกรุกหรือไม่?
ฉันได้เรียนรู้บางอย่างเกี่ยวกับการใช้งานประเภทที่ขึ้นต่อกันเช่นแบบฝึกหัดนี้แต่ส่วนใหญ่ของพวกเขากำลังใช้ล่าม คำถามของฉันคือดูเหมือนว่าการใช้คอมไพเลอร์สำหรับชนิดพึ่งพานั้นยากกว่าคอมไพเลอร์มากเพราะคุณสามารถประเมินอาร์กิวเมนต์ชนิดพึ่งพาได้สำหรับการตรวจสอบชนิด ดังนั้น ความไร้เดียงสาของฉันถูกไหม หากถูกต้องตัวอย่าง / แหล่งข้อมูลเกี่ยวกับการใช้ภาษาที่ตรวจสอบแบบสแตติกสนับสนุนประเภทที่ขึ้นกับอะไรบ้าง
1
ประเภทที่ขึ้นอยู่กับประเภทที่เข้ารหัสของคริสตจักรใน PTS / CoC
ฉันกำลังทดลองกับระบบที่บริสุทธิ์ในก้อนแลมบ์ดาของ Barendregt โดยเฉพาะกับแคลคูลัสออฟคอนสตรัคชั่นที่ทรงพลังที่สุด ระบบนี้มีทุกประเภทและ* BOXสำหรับบันทึกด้านล่างฉันใช้ไวยากรณ์ที่เป็นรูปธรรมของMorteเครื่องมือhttps://github.com/Gabriel439/Haskell-Morte-Libraryซึ่งอยู่ใกล้กับแคลคูลัสแลมบ์ดาคลาสสิก ฉันเห็นว่าเราสามารถเลียนแบบประเภทอุปนัยโดยการเข้ารหัสเหมือนคริสตจักรบางอย่าง (aka Boehm-Berarducci isomorphism สำหรับประเภทข้อมูลพีชคณิต) สำหรับชนิดเช่นฉันใช้งานง่ายBool = ∀(t : *) -> t -> t -> tด้วยการก่อสร้างงานและTrue = λ(t : *) -> λ(x : t) -> λ(y : t) -> xFalse = λ(t : *) -> λ(x : t) -> λ(y : t) -> y ฉันเห็นว่าประเภทของฟังก์ชั่นระดับคำBool …
3
ระบบประเภทขึ้นอยู่กับทฤษฎีเซตไร้เดียงสา
ดังที่ฉันเข้าใจในประเภทข้อมูลวิทยาศาสตร์คอมพิวเตอร์ไม่ได้ตั้งอยู่บนทฤษฎีเซตเนื่องจากสิ่งต่าง ๆ เช่นความขัดแย้งของรัสเซล แต่ในภาษาการเขียนโปรแกรมโลกแห่งความจริงเราไม่สามารถแสดงชนิดข้อมูลที่ซับซ้อนเช่น "ชุดที่ไม่มีตัวเอง" ได้ไหม พูดว่าในประเภทการปฏิบัติเป็นชุดที่ไม่มีที่สิ้นสุดของสมาชิกที่เป็นสมาชิกอินสแตนซ์ที่ถูกกำหนดโดยจำนวนของคุณสมบัติที่อยู่ภายในประเภท / ชุดนี้ (มีคุณสมบัติบางอย่างวิธีการ)? ถ้าไม่มีตัวอย่างแบบ counter จะเป็นอย่างไร
2
สัญชาตญาณเบื้องหลังความเข้มงวดอย่างเข้มงวด?
ฉันสงสัยว่าใครบางคนสามารถให้สัญชาตญาณให้ฉันได้ว่าทำไม positivity ที่เข้มงวดของประเภทข้อมูลอุปนัยรับประกันการฟื้นฟูที่แข็งแกร่ง เพื่อความชัดเจนฉันเห็นว่าการเกิดเหตุการณ์ด้านลบทำให้เกิดความแตกต่างคือการกำหนด: data X where Intro : (X->X) -> X เราสามารถเขียนฟังก์ชันที่แตกต่าง แต่ฉันสงสัยว่าเราจะพิสูจน์ได้อย่างไรว่าประเภทอุปนัยเชิงบวกอย่างเคร่งครัดไม่อนุญาตให้มีความแตกต่าง? นั่นคือมีมาตรการการเหนี่ยวนำบางอย่างที่ช่วยให้เราสามารถสร้างหลักฐานของการทำให้เป็นมาตรฐานที่แข็งแกร่ง (ใช้ความสัมพันธ์เชิงตรรกะหรือคล้ายกัน)? และข้อพิสูจน์ดังกล่าวแตกหักไปที่ไหนสำหรับเหตุการณ์เชิงลบ? มีการอ้างอิงที่ดีที่แสดงการฟื้นฟูที่แข็งแกร่งสำหรับภาษาที่มีประเภทอุปนัยหรือไม่?
1
`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 ใด ๆ …
1
ทฤษฎีประเภท Homotopy และทฤษฎีความไม่สมบูรณ์ของGödel
ทฤษฎีบทที่ไม่สมบูรณ์ของKurt Gödel สร้าง "ข้อ จำกัด โดยธรรมชาติของทุกอย่าง แต่ระบบสัจพจน์ที่น่าสนใจที่สุดที่สามารถทำคณิตศาสตร์ได้" homotopy ประเภททฤษฎีให้เป็นรากฐานทางเลือกสำหรับคณิตศาสตร์เป็นความหมายเดียวรากฐานอยู่บนพื้นฐานของประเภทอุปนัยที่สูงขึ้นและความจริง univalence หนังสือ hottอธิบายว่าประเภท groupoids สูง, ฟังก์ชั่น functors ประเภทครอบครัว brations fi, ฯลฯ บทความล่าสุด"คณิตศาสตร์ที่ผ่านการตรวจสอบอย่างเป็นทางการ"ใน CACM โดย Jeremy Avigad และ John Harrison กล่าวถึง HoTT ในส่วนที่เกี่ยวกับคณิตศาสตร์ที่ผ่านการตรวจสอบอย่างเป็นทางการและการพิสูจน์ทฤษฎีบทอัตโนมัติ ทฤษฎีความไม่สมบูรณ์ของGödelมีผลกับ HoTT หรือไม่? และถ้าพวกเขาทำ ทฤษฎี homotopy ประเภทใดบกพร่องโดยทฤษฎีความไม่สมบูรณ์ของGödel (ภายในบริบทของคณิตศาสตร์ที่ผ่านการตรวจสอบอย่างเป็นทางการ)
2
ประเภทการเป็นเจ้าของและตรรกะการแยก
ประเภทความเป็นเจ้าของและลอจิกการแยกดูเหมือนว่าจะมีเป้าหมายคล้ายกันควบคุมความเป็นเจ้าของและนามแฝง บางทีฉันควรเพิ่ม: ความสามารถในการเขียนข้อมูลจำเพาะแบบแยกส่วน อะไรคือความสัมพันธ์ระหว่างความเป็นเจ้าของและตรรกะการแยก
1
การใช้งานที่เป็นไปได้ของคลาสประเภทของ Haskell คืออะไรและมีข้อได้เปรียบอะไรบ้าง
เท่าที่ฉันทราบฟังก์ชัน Haskell ที่มีข้อ จำกัด ประเภทคลาสจะถูกรวบรวมภายในฟังก์ชันด้วยอาร์กิวเมนต์เพิ่มเติมที่รับพจนานุกรมด้วยการใช้งานที่จำเป็นของคลาสประเภทเฉพาะแต่ละประเภท มีความเป็นไปได้อื่น ๆ อีกหรือไม่ว่าคอมไพล์คลาสชนิดไหน? ถ้าเป็นเช่นนั้นข้อดีของพวกเขาคืออะไร? และคอมไพเลอร์ตัวไหนที่ใช้มัน?
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.