คำถามติดแท็ก lambda-calculus

คำถามพื้นฐาน: อะไรแคลคูลัสแลมบ์ดาทำเพื่อเราว่าเราไม่สามารถทำอะไรกับคุณสมบัติฟังก์ชั่นพื้นฐานและสัญกรณ์เรียนรู้โดยทั่วไปในพีชคณิตโรงเรียนมัธยม? ก่อนอื่นสิ่งที่เป็นนามธรรมหมายถึงอะไรในบริบทของแคลคูลัสแลมบ์ดา? ความเข้าใจของฉันเกี่ยวกับคำว่า abstract เป็นสิ่งที่หย่าร้างจากเครื่องจักรซึ่งเป็นแนวคิดสรุปของแนวคิด อย่างไรก็ตามแลมบ์ดาฟังก์ชั่นโดยทำไปกับชื่อฟังก์ชั่นป้องกันระดับที่เป็นนามธรรม ตัวอย่างเช่น: f(x) = x + 2 h(x, y) = x + 5 y แต่ถึงแม้จะไม่ได้กำหนดกลไกของฟังก์ชั่นเหล่านี้เราก็สามารถพูดคุยเกี่ยวกับองค์ประกอบของมันได้อย่างง่ายดาย ตัวอย่างเช่น: 1. h(x, y) . f(x) . f(x) . h(x, y) or 2. h . f . f . h เราสามารถรวมข้อโต้แย้งหากเราต้องการหรือเราสามารถสรุปได้อย่างสมบูรณ์เพื่อให้ภาพรวมของสิ่งที่เกิดขึ้น และเราสามารถลดพวกมันอย่างรวดเร็วให้เป็นฟังก์ชันเดียว ลองดูองค์ประกอบที่ 2 ฉันสามารถมีรายละเอียดของชั้นนักเรียนที่ฉันสามารถเขียนได้โดยขึ้นอยู่กับความสำคัญของฉัน: g = h . …

18 lambda-calculus  programming-paradigms 

เมื่อไม่นานมานี้ฉันมีความสนใจอย่างมากในการทำความเข้าใจและพิสูจน์แง่มุมของภาษาโปรแกรม (หน้าที่) อย่างไรก็ตามในขณะที่ฉันดำดิ่งลงไปสิ่งต่าง ๆ เช่นแคลคูลัสทฤษฎีหมวดหมู่และความหมายเชิง Denotational นั้นค่อนข้างยากที่จะติดตามโดยไม่มีคำอธิบายที่เหมาะสมλλ\lambda ฉันอ่าน SICP (ค่อนข้างเป็นหนังสือที่รู้แจ้ง) แต่ฉันต้องการดำน้ำลึกลงไปในทฤษฎีของการเขียนโปรแกรมเชิงฟังก์ชั่น มีหนังสือ / บล็อก / ไซต์ / คุณชื่อมันที่จะหารือทฤษฎีของภาษาโปรแกรมการทำงานจากพื้นดินขึ้นหรือไม่

16 reference-request  lambda-calculus  functional-programming  books 

มีเทคนิคใดบ้างในการแก้สมการการทำงานสำหรับฟังก์ชันที่ไม่รู้จักในแคลคูลัสแลมบ์ดา? สมมติว่าฉันมีฟังก์ชั่นระบุตัวตนที่ขยายเพิ่มเติมเช่น: Ix=xIx=xI x = x (นั่นคือโดยการเขียนสมการสำหรับพฤติกรรมที่คาดหวังของฟังก์ชันนั้น) และตอนนี้ฉันต้องการแก้มันสำหรับโดยทำการแปลงพีชคณิตบางอย่างเพื่อให้ได้สูตร intensional สำหรับฟังก์ชันนั้น:III I=λx.xI=λx.xI = \lambda x.x ที่บอกว่าฟังก์ชั่นทำสิ่งที่คาดหวังได้อย่างไร (นั่นคือวิธีการนำไปใช้ในแลมบ์ดาแคลคูลัส) แน่นอนฟังก์ชั่นตัวตนที่ใช้เป็นเพียงตัวอย่าง ฉันสนใจวิธีการทั่วไปในการแก้สมการดังกล่าว โดยเฉพาะฉันต้องการค้นหาฟังก์ชันที่ตรงตามข้อกำหนดต่อไปนี้:BBB Bf(λx.M)=(λx.fM)Bf(λx.M)=(λx.fM)B\;f\;(\lambda x.M) = (\lambda x.f M) นั่นคือ "injects" ฟังก์ชั่นที่กำหนดลงในฟังก์ชั่นแลมบ์ดาต่อหน้า "ร่างกาย" (ซึ่งเป็นนิพจน์แลมบ์ดาโดยพลการ) ซึ่งอาจแยกออกจากกันและสร้างใหม่ขึ้นมา พารามิเตอร์ของฟังก์ชันที่ถูกนำไปใช้fff(λx.M)(λx.M)(\lambda x.M)MMMfff

14 lambda-calculus 

ฉันกำลังอ่านเกี่ยวกับอัลกอริทึมการพิมพ์ของ Hindley-Milnerในขณะที่เขียนการนำไปใช้และดูว่าตราบใดที่ตัวแปรทุกตัวถูกผูกไว้คุณจะได้รับประเภทอะตอมมิกหรือประเภทที่อาร์กิวเมนต์จะกำหนดประเภทสุดท้ายเช่นt1 -> t1หรือ(t1 -> t2) -> (t1 -> t2)ที่ไหนt1และt2เป็นตัวแปรประเภท ฉันไม่สามารถคิดวิธีที่คุณจะได้รับสิ่งที่ชอบt1 -> t2หรือง่ายๆt1ซึ่งฉันเข้าใจว่าหมายความว่าอัลกอริทึมเสียเนื่องจากไม่มีวิธีกำหนดประเภทของนิพจน์ที่แท้จริง คุณจะรู้ได้อย่างไรว่าคุณจะไม่ได้รับประเภทเช่นคนที่ "เสีย" เหล่านี้ตราบใดที่ตัวแปรทุกตัวถูกผูกไว้ ฉันรู้ว่าประเภทอัตราผลตอบแทนขั้นตอนวิธีการที่มีตัวแปร t1 -> t2แต่เหล่านี้ได้รับการแก้ไขเสมอเมื่อคุณผ่านการขัดแย้งกับการทำงานซึ่งจะไม่เป็นกรณีในการทำงานกับชนิด นี่คือเหตุผลที่ฉันต้องการทราบว่าเรารู้ได้อย่างไรว่าอัลกอริทึมจะไม่ให้ผลเช่นนั้น (ดูเหมือนว่าคุณจะได้รับประเภท "เสีย" ใน MLแต่ฉันถามเกี่ยวกับแคลคูลัสแลมบ์ดา)

14 lambda-calculus  type-theory  typing  type-inference 

ใครบางคนสามารถแนะนำให้ฉันดูเอกสารที่ผ่านการตรวจสอบโดยการศึกษาข้อดีหรือข้อเสียของการเขียนโค้ดในรูปแบบการทำงานได้หรือไม่? มีเอกสารที่พูดถึงการใช้งานของแลมบ์ดาแคลคูลัสในสาขาต่าง ๆ เช่นการเรียนรู้ของเครื่องการออกแบบภาษา ฯลฯ หรือไม่?

14 reference-request  programming-languages  lambda-calculus  functional-programming 

คำสั่งที่ใช้บังคับ:ประเมินข้อโต้แย้งของฟังก์ชั่นอย่างเต็มที่ก่อนที่จะประเมินฟังก์ชั่นของตัวเองเช่น - (λx.x2(λx.(x+1) 2)))→(λx.x2(2+1))→ (λx.x2(3))→ 32 → 9(λx.x2(λx.(x+1) 2)))→(λx.x2(2+1))→ (λx.x2(3))→ 32 → 9(\lambda x. x^2(\lambda x.(x+1) \ \ 2))) \rightarrow (\lambda x. x^2(2+1))\rightarrow \ (\lambda x. x^2(3)) \rightarrow \ 3^2 \ \rightarrow \ 9 คำสั่งปกติ:การแสดงออกจะลดลงจากภายนอกในเช่น - (λx.x2(λx.(x+1) 2))→ (λx.(x+1) 2)2→ (2+1)2 →32 → 9(λx.x2(λx.(x+1) 2))→ (λx.(x+1) 2)2→ (2+1)2 →32 → …

14 logic  lambda-calculus  normal-forms 

บทเรียนส่วนใหญ่เกี่ยวกับแลมบ์ดาแคลคูลัสให้ตัวอย่างที่ฟังก์ชัน Integers และ Booleans ที่เป็นบวกสามารถแสดงได้ -1 แล้วฉันล่ะ

14 data-structures  lambda-calculus  integers  real-numbers 

ฉันคิดว่าฉันค่อนข้างสับสนเกี่ยวกับสิ่งที่เรียกว่าแคลคูลัสและสิ่งที่เรียกว่าภาษาการเขียนโปรแกรม ฉันมักจะคิดและอาจได้รับแจ้งว่าแคลคูลัสเป็นระบบที่เป็นทางการสำหรับการให้เหตุผลเกี่ยวกับความเท่าเทียมกันของโปรแกรม โปรแกรมมีความหมายในการปฏิบัติงานที่ระบุโดยเครื่องซึ่งควร (ฉันคิดว่า?) กำหนดได้ ด้วยวิธีนี้แคลคูลัส (ที่ถูกต้อง) สำหรับภาษาเป็นวิธีการพิสูจน์สำหรับการเทียบเท่าของโปรแกรมLLL ดูเหมือนจะเป็นการแบ่งที่สมเหตุสมผลสำหรับฉัน แต่นี่เป็นความหมายที่ยอมรับกันโดยทั่วไปหรือไม่ หรืออาจจะผิดก็ได้ เกี่ยวข้องทำไมความหมายของการดำเนินงานแบบ nondeterministic (สมมติว่ามันไหลมารวมกัน)? อะไรคือสิ่งที่ได้รับจากการเปิดตัวเลือกกลยุทธ์? ฉันขอขอบคุณการชี้แจงเกี่ยวกับสิ่งเหล่านี้ และการอ้างอิงที่เป็นรูปธรรมมากยิ่งขึ้น! ขอบคุณ!

13 terminology  programming-languages  lambda-calculus  semantics  operational-semantics 

นิพจน์ combinator (สมมุติในพื้นฐาน SK) อาจถูกคิดว่าเป็นฟังก์ชั่นที่แมปนิพจน์แคลคูลัสของ combinator กับนิพจน์แคลคูลัสของ combinator นั่นคือเราสามารถนึกถึงนิพจน์เป็นฟังก์ชันX : L → Lโดยที่Lคือชุดของนิพจน์ combinator ที่ถูกต้องทั้งหมดในไวยากรณ์ SK การแมปนี้ดำเนินการโดยใช้อินพุตกับนิพจน์แล้วลดเป็นรูปแบบปกติเพื่อรับเอาต์พุตXXXX:L→LX:L→LX:L \to LLLL ตั้งแต่พื้นฐาน SK เป็นทัวริงสมบูรณ์หนึ่งอย่างไร้เดียงสาอาจจะคิดว่ามีอยู่หนึ่ง SK แสดงออกว่าการดำเนินการใด ๆ ฟังก์ชั่นคำนวณจากLเพื่อL อย่างไรก็ตามนี่ไม่ใช่กรณีที่ชัดเจนเนื่องจากผลลัพธ์ของการลดลงจะอยู่ในรูปแบบปกติเสมอ ซึ่งหมายความว่าไม่มีทางที่นิพจน์จะมีเอาต์พุตที่ไม่อยู่ในรูปแบบปกติXXXLLLLLL ดังนั้นฉันคิดว่านิพจน์ SK แคลคูลัสเป็นการจับคู่กับL ′โดยที่L ′คือเซตของนิพจน์ SK ในรูปแบบปกติ มันเป็นกรณีที่สำหรับแผนที่คำนวณใด ๆF : L ' → L 'มีการแสดงออก SK Xที่ใช้แผนที่นี้อย่างไร? หรือมีข้อ จำกัด เพิ่มเติมเกี่ยวกับชุดฟังก์ชันที่สามารถคำนวณโดยนิพจน์แคลคูลัสของ combinator ด้วยวิธีนี้หรือไม่L′L′L'L′L′L'L′L′L'f:L′→L′f:L′→L′f:L'\to …

13 lambda-calculus  combinatory-logic 

ฉันต้องการตัวอย่างของหนึ่งควินบริสุทธิ์แคลคูลัสแลมบ์ดา ฉันค่อนข้างแปลกใจที่ฉันไม่สามารถหาได้โดย googling หน้า quine แสดงรายการ quines สำหรับภาษา "ของจริง" มากมาย แต่ไม่ใช่สำหรับแคลคูลัสแลมบ์ดา แน่นอนนี่หมายถึงการกำหนดสิ่งที่ฉันหมายถึงโดยควินินในแลมบ์ดาแคลคูลัสซึ่งฉันทำด้านล่าง (ฉันขอสิ่งที่เฉพาะเจาะจงมาก) ในบางแห่งเช่น Larkin และ Stocks (2004) ฉันเห็นข้อความต่อไปนี้ว่าเป็น "การเลียนแบบตัวเอง": (λx.xx)(λx.xx)(λx.xx)(λx.xx)(\lambda x.x \; x)\;(\lambda x.x \; x) ) สิ่งนี้จะลดตัวเองลงหลังจากขั้นตอนการลดเบต้าเพียงครั้งเดียว อย่างไรก็ตามมันไม่เหมือนควินินในที่มันไม่ยุติ: การลดเบต้าเพิ่มเติมจะทำให้เกิดนิพจน์เดียวกันดังนั้นมันจะไม่ลดลงเป็นรูปแบบปกติ สำหรับฉันควินเป็นโปรแกรมที่ยกเลิกและส่งออกตัวเองและดังนั้นฉันต้องการแสดงออกแลมบ์ดาที่มีคุณสมบัตินั้น แน่นอนว่าการแสดงออกใด ๆ ที่ไม่มี redexes อยู่ในรูปแบบปกติแล้วจึงจะยุติและส่งออกเอง แต่นั่นเป็นเรื่องเล็กน้อย ดังนั้นฉันจึงเสนอคำนิยามต่อไปนี้ด้วยความหวังว่ามันจะยอมรับวิธีแก้ปัญหาที่ไม่สำคัญ: คำนิยาม (เบื้องต้น): เป็นควินในแลมบ์ดาแคลคูลัสคือการแสดงออกของรูปแบบ (λx.A)(λx.A)(\lambda x . A) (ที่ยืนสำหรับบางคนการแสดงออกเฉพาะแลมบ์ดาแคลคูลัส) เช่นที่( ( λ …

13 lambda-calculus 

ฟังก์ชั่นการเขียนโปรแกรมมีแลมบ์ดาแคลคูลัสที่สง่างามและตัวแปรในฐานะทฤษฎีสำรอง มีสิ่งนี้สำหรับ OOP หรือไม่? นามธรรมสำหรับแบบจำลองเชิงวัตถุคืออะไร

13 terminology  lambda-calculus  functional-programming  object-oriented 

ผมเคยถามคำถามที่คล้ายกันใน cstheory.SE ตามคำตอบเกี่ยวกับเรื่องนี้ Stackoverflowมีขั้นตอนวิธีว่าในวันที่ไม่ได้ขี้เกียจบริสุทธิ์ภาษาเขียนโปรแกรมการทำงานมีความซับซ้อนในขณะที่วิธีเดียวกันในการเขียนโปรแกรมที่จำเป็นคือΩ ( n ) เพิ่ม lazyness ภาษา FP จะทำให้ขั้นตอนวิธีΩ ( n )Ω ( n บันทึกn )Ω(nlog⁡n)\Omega(n \log n)Ω ( n )Ω(n)\Omega(n)Ω ( n )Ω(n)\Omega(n) มีความสัมพันธ์ที่เท่าเทียมกันเปรียบเทียบภาษา FP กับและไม่มีฟังก์ชั่นการสั่งซื้อที่สูงขึ้นหรือไม่ ทัวริงยังสมบูรณ์อยู่หรือไม่? ถ้าเป็นเช่นนั้นการขาดลำดับที่สูงขึ้นของ FP จะทำให้ภาษามีประสิทธิภาพน้อยลงหรือมีประสิทธิภาพหรือไม่

13 complexity-theory  lambda-calculus  functional-programming  turing-completeness 

ประการแรกฉันอยากจะบอกว่าข้อความของฉันด้านล่างอาจมีข้อผิดพลาดดังนั้นโปรดชี้ข้อผิดพลาดใด ๆ ในการกำหนดคำถามของฉัน พิจารณาแคลคูลัสแลมบ์ดาที่ไม่ได้พิมพ์ด้วย booleans และ if-statement ซึ่งคำเหล่านี้ให้ไว้โดยไวยากรณ์นี้: t ::= v | t t | if t t t | x v ::= \x.t | #t | #f บริบท C ในกรณีนี้จะได้รับตามไวยากรณ์นี้: C ::= [-] | \x. C | C t | t C | if C t t | if …

12 programming-languages  lambda-calculus 

ฉันพยายามที่จะเข้าใจไวยากรณ์ที่ไวต่อบริบท ฉันเข้าใจว่าทำไมภาษาเช่น { w w ∣ w ∈ A* * * *}{ww∣w∈A∗}\{ww \mid w \in A^*\} {anbncn∣n∈N}{anbncn∣n∈N}\{a^n b^n c^n \mid n\in\mathbb{N}\} ไม่ใช่บริบทฟรี แต่สิ่งที่ฉันอยากรู้ว่าภาษาที่คล้ายกับแคลคูลัสแลมบ์ดาที่ไม่ได้พิมพ์ออกมานั้นเป็นบริบทที่อ่อนไหวหรือไม่ ฉันต้องการดูตัวอย่างของแบบง่าย ๆ แต่ไม่ใช่ของเล่น (ฉันพิจารณาตัวอย่างของเล่นด้านบน) ตัวอย่างของไวยากรณ์ไวตามบริบทที่สามารถสำหรับกฎการผลิตบางอย่างเช่นบอกว่าสัญลักษณ์บางอย่างหรือไม่ อยู่ในขอบเขตปัจจุบัน (เช่นเมื่อสร้างเนื้อหาของฟังก์ชัน) ไวยากรณ์ไวตามบริบทมีพลังมากพอที่จะทำให้ตัวแปรที่ไม่ถูกกำหนด / ไม่ได้ประกาศ / ไม่ถูกผูกไว้เป็นข้อผิดพลาดทางไวยากรณ์ (แทนที่จะเป็นความหมาย) หรือไม่

12 formal-grammars  programming-languages  lambda-calculus  context-sensitive 

ฉันกำลังมองหาที่แคลคูลัสของการก่อสร้างและสถานที่ในแลมบ์ดา Cube ถ้าผมเข้าใจอย่างถูกต้องแกนของลูกบาศก์แต่ละคนสามารถจะคิดว่าเป็นการเพิ่มการดำเนินการอื่นที่เกี่ยวข้องกับประเภทที่จะแคลคูลัสเพียงแค่พิมพ์, \แกนแรกจะเพิ่มตัวดำเนินการชนิดต่อคำ, ตัวดำเนินการชนิดต่อชนิดที่สองและตัวพิมพ์ที่สามที่ขึ้นอยู่กับหรือตัวดำเนินการแบบระยะต่อชนิด CoC มีทั้งหมดสามอย่างλ→λ→\lambda_\to อย่างไรก็ตาม CoC แนะนำคำว่าและระบุว่าตามกฎการอนุมานแต่ไม่ได้ใช้ ฉันเข้าใจว่ามันมีไว้สำหรับข้อเสนอที่บาร์นี้ แต่ข้อเสนอเชิงตรรกะไม่ได้กำหนดไว้ในแง่ของมันPropPropPropProp:TypeProp:TypeProp : Type คุณช่วยอธิบายให้ฉันฟังได้ว่าสำหรับอะไรที่ไหน / เมื่อไหร่และอธิบายในแง่ของแกนของลูกบาศก์ (ถ้าเป็นไปได้ที่จะทำเช่นนั้น)PropPropProp

11 terminology  lambda-calculus  type-theory  dependent-types