แคลคูลัสกับการสะท้อน

ฉันกำลังมองหาแคลคูลัสง่ายๆที่สนับสนุนการให้เหตุผลเกี่ยวกับการสะท้อนกลับคือการวิปัสสนาและการจัดการโปรแกรมที่กำลังทำงานอยู่

คือมี untyped ขยายแคลคูลัสที่ช่วยให้หนึ่งในการแปลงλ -terms ลงในแบบฟอร์มที่สามารถจัดการ syntactically แล้วประเมินผลภายหลังหรือไม่?$\lambda$$\lambda$

ฉันจินตนาการว่าแคลคูลัสมีสองคำหลักเพิ่มเติม

• : ใช้เวลาวีและผลิตตัวแทนของโวลต์ทำให้ถูกต้องในการจัดการประโยค$\mathtt{reflect}\ v$$v$$v$
• : ใช้การแทนประโยคของคำศัพท์และประเมินมัน$\mathtt{eval}\ v$

เพื่อสนับสนุนการสะท้อนจำเป็นต้องมีการแสดงคำศัพท์ทางวากยสัมพันธ์ มันจะมีลักษณะเช่น:

• จะแสดงเป็นระยะ ( L M R ( E ) )ที่ R ( E )เป็นรุ่นที่สะท้อนให้เห็นของอี ,$\lambda x.e$$(\mathsf{LAM}\ R(e))$$R(e)$$e$
• จะแสดงเป็นคำ ( A P P R ( e ) R ( e ′ ) )และ$e\ e'$$(\mathsf{APP}\ R(e)\ R(e'))$
• จะแสดงเป็น ( V R x )$x$$(\mathsf{VAR}\ x)$

ด้วยการเป็นตัวแทนนี้การจับคู่รูปแบบสามารถใช้ในการจัดการข้อกำหนด

แต่เราพบปัญหา และอีวีลิตรจะต้องมีการเข้ารหัสเป็นเงื่อนไขเช่นเดียวกับการจับคู่รูปแบบ การจัดการกับนี้น่าจะตรงไปตรงมาเพิ่มR E F L E C T , E V LและM T C Hแต่ฉันจะต้องเพิ่มเงื่อนไขอื่น ๆ เพื่อสนับสนุนการจัดการของเหล่านี้หรือไม่$\mathtt{reflect}$$\mathtt{eval}$$\mathsf{REFLECT}$$\mathsf{EVAL}$$\mathsf{MATCH}$

มีตัวเลือกการออกแบบที่ต้องทำ สิ่งที่ควรฟังก์ชั่นพูดพาดพิงถึงข้างต้นจะทำอย่างไรกับร่างของอาร์อีเอฟลิตรอีคทีและอีวีลิตร ? ควรR ( - )เปลี่ยนร่างกายหรือไม่?$R(-)$$\mathtt{reflect}$$\mathtt{eval}$$R(-)$

ในขณะที่ฉันไม่ได้สนใจศึกษาการสะท้อนตัวเองมากนักแคลคูลัสจะทำหน้าที่เป็นยานพาหนะสำหรับการวิจัยอื่น ๆ ฉันไม่ต้องการบูรณาการล้อ

มีแคลคูลัสอยู่บ้างที่ตรงกับที่ฉันเพิ่งอธิบาย

เท่าที่ฉันสามารถบอกได้ calculi เช่น MetaML ที่แนะนำในความคิดเห็นไปไกล แต่พวกเขาไม่ได้มีความสามารถในการจับคู่รูปแบบและแยกชิ้นส่วนรหัสที่ได้สร้างขึ้นแล้ว

สิ่งหนึ่งที่ฉันอยากจะทำคือ:

• $\mathtt{let}\ x=\lambda y.y\ \mathtt{in}\ \mathtt{reflect}\ x \to (\mathsf{LAM}\ (\mathsf{VAR}\ y)\ (\mathsf{VAR}\ y))$

จากนั้นทำการจับคู่รูปแบบกับผลลัพธ์เพื่อสร้างนิพจน์ที่แตกต่างอย่างสิ้นเชิง

แน่นอนว่านี่ไม่ใช่ส่วนขยายอนุรักษ์นิยมไปสู่ -calculus และ meta-theory น่าจะเป็นสิ่งที่น่าเกลียด แต่นี่เป็นประเด็นสำหรับการสมัครของฉัน ฉันต้องการที่จะทำลายλ -abstractions ออกจากกัน$\lambda$$\lambda$

Jean Louis Krivine แนะนำแคลคูลัสเชิงนามธรรมที่ขยาย "Krivine Machine" ในแบบที่ไม่สำคัญมาก (โปรดทราบว่าเครื่อง Krivine รองรับการเรียนการสอนการโทร / cc จากเสียงกระเพื่อม):

เขาแนะนำ "อ้าง" ผู้ประกอบการในบทความนี้ที่กำหนดไว้ในลักษณะดังต่อไปนี้: ถ้าเป็นλระยะทราบn ไวภาพของφโดยบาง bijection π : Λ →การNจากแง่แลมบ์ดาไปยังหมายเลขธรรมชาติ หมายเหตุ¯ nเลขโบสถ์ซึ่งสอดคล้องกับn ∈ N Krivine กำหนดโอเปอเรเตอร์χตามกฎการประเมิน: χ ϕ → ϕ ¯ n $\phi$$\lambda$$n_\phi$$\phi$$\pi: \Lambda \rightarrow \mathbb{N}$$\overline{n}$$n\in\mathbb{N}$$\chi$

โปรดทราบว่า Krivine นั้นยากที่จะอ่าน (โปรดอย่าโกรธถ้าคุณอ่านเรื่องนี้ Jean-Louis!) และนักวิจัยบางคนได้ทำการกุศลเพื่อพยายามดึงเนื้อหาทางเทคนิคออกมาให้อ่านได้ง่ายขึ้น คุณอาจลองดูบันทึกย่อเหล่านี้โดย Christophe Raffali

หวังว่านี่จะช่วยได้!

มันเกิดขึ้นกับผมว่ามีการอ้างอิงที่อาจจะเกี่ยวข้องกับความสนใจของคุณอีกคือแบบเพียวแคลคูลัสโดยเจและ Kesner formalizes แตกต่างจากที่แคลคูลัสซึ่งทอดตัวเป็นนามธรรมที่เรียบง่ายมากกว่าตัวแปรเพื่อเป็นนามธรรมมากกว่ารูปแบบที่เป็นตัวแทนของแคลคูลัสรูปแบบ ตัวเอง นี่เป็นสิ่งที่แสดงให้เห็นถึงปรากฎการณ์และโดยเฉพาะอย่างยิ่งอนุญาตให้หนึ่งใน deconstruct แอปพลิเคชันตัวเอง: ถ้าฉันไม่ผิดคำ:$\lambda$

ลด x อีกครั้งผมเชื่อว่านี่เป็นมากกว่าเพียงพอที่จะใช้คำพูดและEVALผู้ประกอบการ$\lambda x.x\ x$

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

ฉันเชื่อว่าการมีความสามารถนี้จะทำสิ่งที่ไม่ดีกับทฤษฎีสมการของคุณ โดยเฉพาะอย่างยิ่งคุณจะมีแนวโน้มที่จะสามารถพิสูจน์ได้ว่าสองค่ามีค่าเท่ากันถ้าค่านั้นเท่ากันถึงค่าอัลฟา

ฉันยังไม่ได้อ่านโคดี้กระดาษ Krivine ที่เชื่อมโยงกับ แต่ฉันควรทราบว่าในตรรกะคลาสสิกคุณเป็นหลักมีเพียงสองสิ่ง: จริงและเท็จ ทุกอย่างเทียบเท่ากับหนึ่งในนั้น นั่นคือคุณมีแนวโน้มที่จะมีทฤษฎีสมการที่ยุบลงไป

ในทฤษฎีภาษาการเขียนโปรแกรมคุณลักษณะที่คุณพูดถึงมักจะเรียกว่า "อ้าง" ตัวอย่างเช่น John Longley เขียนเกี่ยวกับเรื่องนี้ในงานของเขาดูบทความนี้

หากคุณเป็นเพียงหลังจากการพิจารณาทางทฤษฎี (ตรงข้ามกับการใช้งานที่มีประโยชน์จริง ๆ ) จากนั้นคุณสามารถทำให้สิ่งต่าง ๆ ง่ายขึ้นโดยระบุว่าแผนที่quote(หรือreflectตามที่คุณเรียกว่า) แผนที่เป็นประเภทของจำนวนเต็มnatโดยส่งคืนรหัสGödelของอาร์กิวเมนต์ จากนั้นคุณสามารถแยกตัวเลขเช่นเดียวกับทรีของคุณที่มีโครงสร้างแบบนามธรรม นอกจากนี้คุณไม่จำเป็นต้องใช้evalเพราะมันสามารถนำไปใช้ในภาษา - มันเป็นล่ามสำหรับภาษา

สำหรับรูปแบบที่เป็นรูปธรรมซึ่งมีคุณสมบัติเหล่านี้คุณสามารถพิจารณาพีชคณิต combinatory Kleene เป็นครั้งแรก: เข้าใจทุกอย่างเป็นตัวเลข (คิดว่าพวกเขาเป็นรหัสGödel) และกำหนดโปรแกรมประยุกต์ Kleene ค่าเฉลี่ยφ n ( ม. )ที่φ nเป็นn - ฟังก์ชั่นบางส่วน นี้จะให้รูปแบบของλแคลคูลัส (มีแผนที่บางส่วน) ซึ่งเป็นเพียงฟังก์ชั่นตัวตน ไม่จำเป็นต้องเพิ่มฟีเจอร์เพิ่มเติมลงในภาษา$n \star m$$\varphi_n(m)$$\varphi_n$$n$$\lambda$quote

ถ้าคุณบอกฉันว่าคุณกำลังทำอะไรฉันจะให้ข้อมูลอ้างอิงที่เฉพาะเจาะจงแก่คุณมากขึ้น

โดยวิธีการที่นี่เป็นปัญหาที่เปิดอยู่:

Enrich แคลคูลัส (พิมพ์หรือ untyped) ด้วยซึ่งเป็นความสอดคล้องกันในลักษณะที่คุณสามารถเก็บรักษาได้ξ -rule$\lambda$quote$\xi$

-rule อี1 ≡ อี$\xi$กล่าวว่าλ-abstraction เป็นความสอดคล้องกัน มันช่วยให้เราสามารถลดภายใต้λเพื่อที่จะพูด เมื่อใช้ร่วมกับสิ่งนี้จะกลายเป็นปัญหาได้เนื่องจากควรจะมีความสอดคล้องเช่นกัน e1≡e

Here is an alternative answer, instead of using my nominal approach which is still experimental there is some more established approach that goes back to the paper:

LEAP: A language with eval and polymorphism
Frank Pfenning and Peter Lee
https://www.cs.cmu.edu/~fp/papers/tapsoft89.pdf

The paper starts with:

This then led us to the question, first posed by Reynolds, of whether strongly typed languages admit metacircular interpreters. Conventional wisdom seemed to indicate that the answer was "No". Our answer is "Almost".

Please note that LEAP is much stronger than what the OP wants. First of all it is typed. And second it asks for metacircularity, which means for example that eval can execute its own definition. In Prolog you get metacircularity for solve/1:

solve(true).
solve((A,B)) :- solve(A), solve(B).
solve(H) :- clause(H,B), solve(B).

If you add the following clause to solve/1:

solve(clause(H,B)) :- clause(H,B).

And if you see to it that clause/2 also returns the clauses of solve/1. You can then call solve(solve(...)) and see how solve executes itself.

Questions of self representatio still spurr some research, see for example:

Self representation in Girards System U
Matt Brown, Jens Palsberg
http://compilers.cs.ucla.edu/popl15/popl15-full.pdf

The problem is identified in vincinity of proof assistants such as Coq and Isabelle/HOL. It goes under the acronym HOAS. There are some claims around λ-Prolog that through the new ∇ quantifier such things can be done. But I couldn't get a grip yet of this claim. I guess the main insight I got so far is that there is no definite approach, there are a couple of possible approaches.

My own take, not yet finished, is inspired by a recent paper by Paulson on proving Gödels incompletness. I would use the object-level binders in connection with some data structure that has the meta-level names. Basically a similar yet distinct data structure as the one from the OP, and with Church coding since I am interested in dependent types:

datatype Expr = var Name                 /* written as n */
              | app Expr Expr            /* written as s t */
              | abs Name Expr Expr       /* written as λn:s.t */

The meta level expressions can be distinguished from the object level expressions in that we use the variable names n, m, .. etc.. to denote names. Whereas we use the variable names x, y, .. etc.. on the object level. The interpretation of a meta term in the object logic would then work as follows. Lets write [t]σ for the interpretation of the nominal term t in the nominal context σ, which should give an object term. We would then have:

 [n]σ = lookup σ n
 [s t]σ = [s]σ [t]σ
 [λn:s.t]σ = λx:[s]σ.[t]σ,n:x

The above would define what the OP calls an EVAL function. Small difference to Paulson, σ is only a finite list and not a functional. In my opinion it would be only possible to introduce an EVAL function and not a REFLECT function. Since on the object level you might have some equality so that different lambda expressions are the same. What you have to do would be to use eval to reason possibly also about reflection if you feel the need.

You would need to go to extremes like Prolog where nothing is expanded, if you want to tear down the wall between nominal and non-nominal. But as the λ-Prolog system example shows, in the higher-order case there are luring additional problems which can for example only be overcome in logical way by introducing new means such as a ∇ quantifier!