การแทนค่าตัวแปรที่ถูกผูกไว้กับฟังก์ชั่นจากการใช้งานเพื่อยึดประสาน

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

แต่ดูเหมือนว่าจะมีวิธีอื่นที่ค่อนข้างชัดเจนซึ่งฉันไม่เคยเห็นมาก่อนเลย กล่าวคือในไวยากรณ์พื้นฐานเรามีเพียงหนึ่ง "ตัวแปร" คำพูดที่เขียนแล้วแยกเราให้ฟังก์ชั่นที่แผนที่แต่ละตัวแปรเครื่องผูกในที่มีขอบเขตมันโกหก ดังนั้นλระยะยาวเช่น$\bullet$$\lambda$

จะเขียนλและฟังก์ชั่นจะ map แรก∙แรกλและครั้งที่สอง∙ที่สองλ ดังนั้นมันเหมือนกับดัชนี de Bruijn เพียงแทนที่จะต้อง "นับλ s" เมื่อคุณกลับออกจากคำศัพท์เพื่อค้นหาสารยึดเกาะที่สอดคล้องกันคุณเพียงแค่ประเมินฟังก์ชั่น (หากแสดงสิ่งนี้เป็นโครงสร้างข้อมูลในการดำเนินการฉันจะคิดว่าการจัดเตรียมออบเจ็กต์คำศัพท์แต่ละตัวแปรด้วยตัวชี้ / การอ้างอิงอย่างง่ายไปยังออบเจ็กต์คำที่สอดคล้องกัน)$\lambda. (\lambda. \bullet\bullet)$$\bullet$$\lambda$$\bullet$$\lambda$$\lambda$

เห็นได้ชัดว่าสิ่งนี้ไม่เหมาะสมสำหรับการเขียนไวยากรณ์บนหน้าเว็บเพื่อให้มนุษย์อ่าน แต่แล้วก็ไม่มีดัชนี de Bruijn ฉันคิดว่ามันสมเหตุสมผลดีทางคณิตศาสตร์และโดยเฉพาะอย่างยิ่งมันทำให้การทดแทนการหลีกเลี่ยงการจับภาพเป็นเรื่องง่ายมาก: เพียงแค่วางในเทอมที่คุณใช้แทนและใช้ฟังก์ชันการรวมกัน มันเป็นความจริงที่ว่ามันไม่ได้มีความคิดเกี่ยวกับ "ตัวแปรอิสระ" แต่แล้ว (อีกครั้ง) ไม่ได้ทำดัชนีเดอบรูจน์จริง ๆ ; ในทั้งสองกรณีคำที่มีตัวแปรอิสระจะแสดงคำที่มีรายการ "ตัวยึด" บริบทอยู่ด้านหน้า

ฉันทำบางสิ่งบางอย่างหายไปและมีเหตุผลบางอย่างที่การแสดงนี้ไม่ทำงานหรือไม่ มีปัญหาที่ทำให้แย่กว่าคนอื่น ๆ ที่ไม่คุ้มค่าหรือไม่ (ปัญหาเดียวที่ฉันคิดได้ในตอนนี้คือชุดของข้อตกลง (พร้อมกับฟังก์ชั่นการผูก) ไม่ได้ถูกกำหนดแบบเหนี่ยวนำ

คำตอบของ Andrej และŁukaszให้คะแนนดี แต่ฉันต้องการเพิ่มความคิดเห็นเพิ่มเติม

เพื่อสะท้อนสิ่งที่ Damiano พูดวิธีการแสดงความผูกพันโดยใช้พอยน์เตอร์เป็นสิ่งที่เสนอโดยการพิสูจน์อวน แต่สถานที่ที่เก่าแก่ที่สุดที่ฉันเห็นมันสำหรับศัพท์แลมบ์ดาอยู่ในบทความเก่า ๆ ของ Knuth:

• Donald Knuth (1970) ตัวอย่างของความหมายที่เป็นทางการ ในการประชุมสัมมนาเกี่ยวกับความหมายของภาษาอัลกอริทึม , E. Engeler (ed.), บันทึกการบรรยายในวิชาคณิตศาสตร์ 188, สปริงเกอร์

$(\lambda y.\lambda z.yz)x$

การแสดงภาพกราฟิกของคำแลมบ์ดานี้ได้ศึกษาอย่างอิสระ (และลึกซึ้งยิ่งขึ้น) ในสองวิทยานิพนธ์ในต้นปี 1970 ทั้งโดย Christopher Wadsworth (1971, Semantics และ Pragmatics ของ Lambda-แคลคูลัส ) และ Richard Statman (1974, ความซับซ้อนของโครงสร้าง ของการพิสูจน์ ) ทุกวันนี้ไดอะแกรมดังกล่าวมักถูกเรียกว่า "graph-graphs" (ดูตัวอย่างกระดาษนี้ )

สังเกตว่าคำในแผนภาพของ Knuth นั้นเป็นแบบเส้นตรงในแง่ที่ว่าตัวแปรอิสระหรือขอบเขตถูกเกิดขึ้นทุกครั้ง - อย่างที่คนอื่น ๆ พูดถึงมันมีประเด็นที่ไม่น่าสนใจ - ข้อตกลงเชิงเส้น

$\alpha$

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

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

ในแคลคูลัสแลมบ์ดาทั่วไปที่พิมพ์, การลดลงและการหดตัว, ตรงกันข้ามกับกฎอื่น ๆ , ไม่มีไวยากรณ์

ลองเพิ่มรูปแบบ:

$C_a^{b,c}(\cdot)$$a$$b,c$

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

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

นอกจากนี้การปฏิรูปนี้ช่วยให้เราสามารถติดตามการลบคัดลอกและแบ่งปันด้วยความซื่อสัตย์มากขึ้น หนึ่งสามารถเขียนกฎที่คัดลอก (หรือลบ) คำที่เพิ่มขึ้นในขณะที่การแบ่งปันคำ มีหลายวิธีที่จะทำเช่นนั้น ในการตั้งค่าการ จำกัด บางชนะค่อนข้างน่าแปลกใจ

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

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

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

แต่ฉันยินดีที่ได้เห็นการทดสอบ! คุณสามารถใช้lambdaและนำไปใช้กับโครงสร้างข้อมูลของคุณ (OCaml มีตัวชี้พวกเขาเรียกว่าการอ้างอิง ) มากขึ้นหรือน้อยลงคุณเพียงแค่ต้องแทนที่syntax.mlและnorm.mlใช้เวอร์ชันของคุณ นั่นคือน้อยกว่า 150 บรรทัดของรหัส

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

เมื่อคุณพูดว่า "ฟังก์ชั่นที่แมปตัวแปรแต่ละตัวเข้ากับตัวยึดที่มีขอบเขตอยู่": ประเภทเอาต์พุตของฟังก์ชั่นนี้ย่อมดีกว่าบิตที่ทำให้เกิดเสียง! โดยเฉพาะฟังก์ชั่นจะต้องใช้ค่าในบางสิ่งบางอย่างเช่น "ตัวประสานของคำที่อยู่ในการพิจารณา" - เช่นชุดที่แตกต่างกันไปขึ้นอยู่กับคำว่า (และไม่ชัดเจนว่าเป็นเซตย่อยของชุดบรรยากาศขนาดใหญ่ในลักษณะที่เป็นประโยชน์ใด ๆ ) ดังนั้นในการทดแทนคุณไม่สามารถเพียงแค่“ นำฟังก์ชันการรวมเข้าด้วยกัน”: คุณต้องทำดัชนีค่าของพวกเขาใหม่ตามแผนที่บางส่วนจากสารยึดเกาะในคำดั้งเดิมไปยังตัวยึดผลของการทดแทน

การสร้างดัชนีใหม่เหล่านี้ควรเป็น“ งานประจำ” อย่างแน่นอนในแง่ที่ว่าพวกเขาสามารถกวาดใต้พรมได้อย่างมีเหตุผลหรือบรรจุหีบห่ออย่างดีในแง่ของความเป็นมนุษย์หรือธรรมชาติ แต่สิ่งเดียวกันนี้เป็นจริงของการทำบัญชีที่เกี่ยวข้องกับการทำงานกับตัวแปรที่มีชื่อ โดยรวมแล้วดูเหมือนว่าฉันจะมีการทำบัญชีอย่างน้อยเกี่ยวกับวิธีนี้เช่นเดียวกับวิธีมาตรฐานที่มากกว่า

แม้ว่านี่เป็นแนวทางที่น่าสนใจมากและฉันชอบที่จะเห็นมันออกมาอย่างรอบคอบ - ฉันนึกภาพออกมาได้ว่ามันอาจทำให้เกิดความแตกต่างในแง่มุมของไวยากรณ์มากกว่าวิธีมาตรฐาน

$\lambda$Lazy.t

โดยรวมแล้วฉันคิดว่ามันเป็นตัวแทนที่ยอดเยี่ยม แต่มันเกี่ยวข้องกับการทำบัญชีกับพอยน์เตอร์เพื่อหลีกเลี่ยงการเชื่อมโยงที่มีผลผูกพัน มันเป็นไปได้ที่จะเปลี่ยนรหัสเพื่อใช้ฟิลด์ที่ไม่แน่นอนที่ฉันเดาได้ แต่การเข้ารหัสใน Coq นั้นจะน้อยกว่าโดยตรง ฉันยังคงเชื่อว่าสิ่งนี้คล้ายกับ HOAS มากถึงแม้ว่าโครงสร้างของตัวชี้จะชัดเจน อย่างไรก็ตามการมีอยู่ของLazy.tนัยก็เป็นไปได้ที่จะมีการประเมินรหัสในเวลาที่ผิด นี่ไม่ใช่กรณีในรหัสของฉันเป็นเพียงการทดแทนของตัวแปรที่มีตัวแปรอาจเกิดขึ้นในforceเวลา (และไม่ได้ประเมินตัวอย่าง)

(* Representation of a term of the λ-calculus. *)
type term =
  | FVar of string      (* Free variable  *)
  | BVar of bvar        (* Bound variable *)
  | Appl of term * term (* Application    *)
  | Abst of abst        (* Abstraction    *)

(* A bound variable is a pointer to the corresponding binder. *)
and bvar = abst

(* A binder is represented as its body in which the bound variable points to
   the binder itself. Note that we need to use a thunk to be able to work
   underneath a binder (for substitution, evaluation, ...). A name can be
   given for easy printing, but no renaming is done. Only “visual capture”
   can happen since pointers are established the right way, even if names
   can clash. *)
and abst = { body : term Lazy.t ; name : string }

(* Terms can be built with recursive values for abstractions. *)

(* Krivine's notation is used for application (function in parentheses). *)

let id    : term = (* λx.x        *)
  Abst(let rec id = {body = lazy (BVar(id)); name = "x"} in id)

let idid  : term = (* (λx.x) λx.x *)
  Appl(id, id)

let delta : term = (* λx.(x) x *)
  Abst(let rec d = {body = lazy (Appl(BVar(d), BVar(d))); name = "x" } in d)

let weird : term = (* (λx.x) λy.(λx.(x) x) (C) y *)
  Appl(id, Abst(let rec x = {body = lazy (Appl(delta, Appl(FVar("C"),
    BVar(x)))); name = "y"} in x))

let omega : term = (* (λx.(x) x) λx.(x) x *)
  Appl(delta, delta)

(* Printing function is immediate. *)
let rec print : out_channel -> term -> unit = fun oc t ->
  match t with
  | FVar(x)   -> output_string oc x
  | BVar(x)   -> output_string oc x.name
  | Appl(t,u) -> Printf.fprintf oc "(%a) %a" print t print u
  | Abst(f)   -> Printf.fprintf oc "λ%s.%a" f.name print (Lazy.force f.body)

(* Substitution of variable [x] by [v] in the term [t]. Occurences of [x] in
   [t] are identified using physical equality ([BVar] case). The subtle case
   is [Abst], because we need to reestablish the physical link between the
   binder and the variable it binds. *)
let rec subst_var : bvar -> term -> term -> term = fun x t v ->
  match t with
  | FVar(_)   -> t
  | BVar(y)   -> if y == x then v else t
  | Appl(t,u) -> Appl(subst_var x t v, subst_var x u v)
  | Abst(f)   ->
      (* First compute the new body. *)
      let fv = subst_var x (Lazy.force f.body) v in
      (* Reestablish the physical link, using [subst_var] itself again. This
         requires a second traversal of the term. We could probably do both
         at once, but who cares the complexity is linear in [t] anyway. *)
      Abst(let rec g = {f with body = lazy (subst_var f fv (BVar(g)))} in g)

(* Actual substitution function. *)
let subst : abst -> term -> term = fun f v ->
  subst_var f (Lazy.force f.body) v

(* Normalization function (all the way, even under binders). *)
let rec eval : term -> term = fun t ->
  match t with
  | Appl(t,u) ->
      begin
        let v = eval u in
        match eval t with
        | Abst(f) -> eval (subst f v)
        | t       -> Appl(t,v)
      end
  | Abst(f)   ->
      (* Actual computation in the body. *)
      let fv = eval (Lazy.force f.body) in
      (* Here, the physical link is reestablished, but it is important to note
         that the computation of evaluation is done above. So the part below
         only takes a linear time in the size of the normal form of the body
         of the abstraction. *)
      Abst(let rec g = {f with body = lazy (subst_var f fv (BVar(g)))} in g)
  | _         ->
      t

let _ = Printf.printf "id         = %a\n%!" print id
let _ = Printf.printf "eval id    = %a\n%!" print (eval id)

let _ = Printf.printf "idid       = %a\n%!" print idid
let _ = Printf.printf "eval idid  = %a\n%!" print (eval idid)

let _ = Printf.printf "delta      = %a\n%!" print delta
let _ = Printf.printf "eval delta = %a\n%!" print (eval delta)

let _ = Printf.printf "omega      = %a\n%!" print omega
(* The following obviously loops. *)
(*let _ = Printf.printf "eval omega = %a\n%!" print (eval omega)*)

let _ = Printf.printf "weird      = %a\n%!" print weird
let _ = Printf.printf "eval weird = %a\n%!" print (eval weird)

(* Output produced:
id         = λx.x
eval id    = λx.x
idid       = (λx.x) λx.x
eval idid  = λx.x
delta      = λx.(x) x
eval delta = λx.(x) x
omega      = (λx.(x) x) λx.(x) x
weird      = (λx.x) λy.(λx.(x) x) (C) y
eval weird = λy.((C) y) (C) y
*)