April 3, 2000 Eli Barzilay [Part II]

Transcription

1 [Part II] Eli Barzilay April 3, 2000

2 Ideology Break General ideology: duplication of functional information is bad, this is the essence of programming. Consequent: the recursive type alone is not a good solution it means that we duplicate the encoding of term structures that is already part of Nuprl itself. The value Scheme s reflection is: The user shares the implementation s data structures. Also, the eval function is shared. Clarity of the connection between the user s eval and the implementation s eval trivial. Eli Barzilay Reflection & Nuprl 1/32

3 Scheme s Approach When it comes to implementing Scheme, these shortcuts are natural: The implementation uses data structures and code that behaves like Scheme s data structures: why use a different representation and translate back and forth? Even clearer when considering eval: execution of quoted code by eval is expected to be the same as execution of code, so using the same function is the obvious solution. Eli Barzilay Reflection & Nuprl 2/32

4 The Problem with Logic The simplicity of Scheme is not seen in a logical system: We must deal with truth and proofs as well as evaluation. This is hard so: we tend to avoid changing the logic a strong point for using Gödel numbers is that the logic itself is not extended. My intuition: when it comes to an implemented, Scheme s insights are extremely useful because they will make reflection practical (as I will show). Eli Barzilay Reflection & Nuprl 3/32

5 Scheme s Approach Avoid the [double] evil of duplicating function in logic: code representation and evaluation are shared with users. It is trivial to get convinced that eval s implementation is correct assuming that the language implementation is itself correct. Eli Barzilay Reflection & Nuprl 4/32

6 Natural Language Natural language is very different than formal language, but it is still a good source of intuition. There are several indications that we use the same parse mechanism for natural language: Parsing is done in real-time the brain is doing the same mental activity (makes being a simultaneous translator so difficult). If quotations were parsed in a different way we would take them as a different language. Eli Barzilay Reflection & Nuprl 5/32

7 # " % and that Eli Barzilay Reflection & Nuprl 6/32 Nuprl s syntax, semantics and rules). each stage depends on the previous. (For example, defining ""is defined in three stages!assume $ and ", have several parts with some dependencies.!in systems that we are interested in, the definition/design will!assume some system "(any kind of system).!try to understand things following some very general example. General Example

8 ' ) /. - - ( & Eli Barzilay Reflection & Nuprl 7/32 as +, we can do the same and get +,, +,,,, *After all this, we get what we want: since +, is exactly the same etc. the same as+. *Finally, we have +, and now we should show that it is exactly *And continue with +, in +using +, and the same for +,. *So we begin by implementing +, in (terms of) +. ++, a reflected version of *Now we want to get within itself. General Example

9 General Example 4If we want to actually have an infinite chain of such embedded systems, we will have to use some circularity (or an infinite piece of paper). 4This can be achieved using the method described earlier. 4Specifically, a fixed-point construction or implementation shortcuts can do this. Eli Barzilay Reflection & Nuprl 8/32

10 6 8 : 7 5 Eli Barzilay Reflection & Nuprl 9/32 9This is the place that programmers should feel that something is going wrong and that logicians wouldn t necessarily be concerned about it doesn t feel good implementing something that we already did. thing is duplicated! and another complete implementation of : ; in:: the whole 9The problem: we have both a complete implementation of General Example

11 =? FA E D D A C > < Eli Barzilay Reflection & Nuprl 10/32 is one thing that Aitken could have used to reduce some... and finally use itself. wrap these two in an interface that FA can use, show that A B A B and are equivalent to EA DA and, do the same thing until we have A B, C and then use it to continue, for example: equivalent way that we can try to solve this show that some A B is General Example

12 H J O NL O P N I G Eli Barzilay Reflection & Nuprl 11/32 from Linto itself. KBut it is better if don t do anything at all: just make shortcuts KWe could do the same right after we get L M. makes this very unnatural. wrap NL somehow, make sure that is accessible by itself, show that L M L M and are the same as those inl, KTook some work off no need for L M, but still need to: General Example

13 R T XV S Q Eli Barzilay Reflection & Nuprl 12/32 (define user-eval (compose rep impl-eval unrep)) Wrap eval in these: internal eval structures, Write translation functions to (unrep) and from rep the Make sure they are equivalent to Scheme s, Create some new data structures in Scheme, UPartial shortcut: UFull scenario: a complete Scheme parser/interpreter in Scheme. : evaluation function. WV : syntax structures, UThis is exactly what happens in Scheme: General Example: The Scheme Side

14 Z \ [ Y General Example: Conclusion ]Better stop and think before trying to implement a reflected system. ]Exposing some internals of a system into itself is the best way to get reflection. ]This might require some changes to the design of the system since the exposed internals usually use mechanisms that have no equivalent in the world of its users (for example, terms in Nuprl). Eli Barzilay Reflection & Nuprl 13/32

15 _ a ` ^ The Nuprl Side bmy strong intuition here is that this applies perfectly to Nuprl. bthe definition stages we have are basically Syntax, Semantics/Evaluation, Inference rules. bcan split further to a more complex DAG. Eli Barzilay Reflection & Nuprl 14/32

16 d f e c The Nuprl Side gmoreover, such shortcuts should also be useful for the paper implementation the design. ga side-effect effect is that implementation details all pop up in the design stage (because we re mixing the two). ga similar case Nuprl uses its implementation s numbers: Goes down to Lisp numbers. Risk: Nuprl s number behave correctly only if Lisp s numbers are OK. If we d use 0 and succ, we wouldn t be able to do a lot of stuff we can do now. Classic tradeoff. Coq? HOL? Eli Barzilay Reflection & Nuprl 15/32

17 i k poand nm1:q,i:l nmi:l po;y,z. po;y,z. poand j h Term Quotations lthe suggested way of doing quotations was add quote parameter, with a value that indicates the quoted-ness level of the term. lfoo foo quoted (x. (x. respectively. ) is quoted as ) where are lchoosing a quotation mechanism turns out to be a crucial decision looks like this one is The Right Thing. Eli Barzilay Reflection & Nuprl 16/32

18 r t s q Term Quotations: The Hard Way umentioned earlier: use a recursive type definition: an opid and a pair of lists. urelies on having an available type theory, bad for Meta-PRL. urepresentation gets exponentially big when a term is quoted over and over, a Scheme example shows this easily: Original expression: (foo x) Quoted once: (list foo x) Quoted twice: (list list (list quote foo) (list quote x)) Eli Barzilay Reflection & Nuprl 17/32

19 w y x v Term Quotations: The Hard Way zthe user-interface problem can be avoided using appropriate I/O mechanisms. zhowever, it is still as efficient as using 0 and succ for integers. zthe main damage this causes is that it leads the whole implementation down the wrong path Aitken s case. zthe single advantage of this is that the logic is not extended. Eli Barzilay Reflection & Nuprl 18/32

20 ~ 1:q,i:l } { Term Quotations: Another Alternative An example for some suggested quotations that didn t go all the way. This is a good example to get the feeling of implementation shortcuts being much better. Make binding variables of subterms be quoted on their own as more subterms supposed to make binding variables more easily accessible (actually, level-expression variables as well, but these are ignored now.). So the above term is quoted as: foo (x; ƒ ;y;z; ) Now the fun begins... Eli Barzilay Reflection & Nuprl 19/32

21 Š <1,[1;2]>:q,i:l Alternative: Problem #1 ˆFirst of all, we have to be really careful about the representation: in the above quotation there is no way to know which quoted subterms are quoted subterms and which are quoted bindings. ˆSolution: make the quote parameter contain more information that describes the quoted term s binding structure. ˆfoo (x; Œ ;y;z; ) ˆThis, again, depends on type theory for the lists. ˆAlso, pulls toward the recursive type solution (except that the integer quote parameter can prevent exponential blowup). Eli Barzilay Reflection & Nuprl 20/32

22 Ž Eli Barzilay Reflection & Nuprl 21/32 This is a place where using built-in terms pays off easily: such problems do not occur with them since we take advantage of existing design decisions. syntax. I thought about this but then Bob said that the is part of the Also what if all terms were bound terms (so variables are associated differently)? Could do the same. aren t quoted. For example, quote only the in all (x.p) getting all <1,[1]>:q (x;p) where both the x and the P Using this quotation method, it is possible to quote a term without any of its subterms. Alternative: Problem #2

23 œ <1,[1;2]>:q,i:l Eli Barzilay Reflection & Nuprl 22/32 and this has no sense as a quoted term. foo žÿ ; ( ;y;z; ) šso, it is possible to enter: has. unrestricted we can t control what subterms a quoted term šanother problem pops up because these quotes are too Alternative: Problem #3

24 » using: Eli Barzilay Reflection & Nuprl 23/32 make. Another point is that nonsensical quoted terms are harder to level. This is even simpler if the quote parameters have an integer ±² ³ µ ¹º ±» ± ¼ µ ¹º ±² ½ ³³³ quoted level ª«ª«given some internal ª«ª«create for every same functionality wrapping it in quotation level shifters, so It is also easy to get reflected functionality as well use the Exposing internal functionality is very simple. Almost completely independent of the underlying logic. Suggested Quotes: Advantages

25 Á À ¾ Quoted Binding Variables ÂThe decision that binding variables are quoted with their surrounding term makes even more sense. ÂQuoting them means that they have no semantic meaning of their own, but they are still binding occurrences in the quoted level. ÂThis can be demonstrated in Scheme: (lambda (x) x) is a simple list with symbols and a sublist but when we treat this on the quoted level, for example as input to eval, the x will have meaning as a binding variable. Eli Barzilay Reflection & Nuprl 24/32

26 Ä Æ È Å Ã Eli Barzilay Reflection & Nuprl 25/32 and ËËÊ. concept for example, because we cannot distinguish ÈÉÊ É ÇMoreover, we cannot talk about alpha-renaming or any related need to expose any alpha-renaming functionality. ÇThis is adds convenience (higher-level abstraction): there is no lists). alpha renaming automatically (similar to representing sets using ÇDoing this is similar to exposing a term package that handles take equivalence classes over alpha-renaming. ÇWe can continue this: instead of using quoted terms we can Terms with Alpha-Equality

27 Í Ï Ô Ô Î Ì Eli Barzilay Reflection & Nuprl 26/32 when we want to allow some variable to appear. instantiated with different variables, and we have to specify ÐThis means that different pattern variables are can only be instantiated with an that contains a free occurrence of Ò. ÐFor example, the rewrite rule ÑÒÓ ÔÒÕÖ cannot be the one used to specify rewrite rules in Meta-PRL. ÐThis can be added to a smart-substitution mechanism such as cannot do with such an interface (for example, display-forms). auto-alpha-renaming package and see what you can and ÐThe intuition here: think about an implementation with a similar Terms with Alpha-Equality

28 Ø Ú æ å Ù Eli Barzilay Reflection & Nuprl 27/32 älines, compared to a previous çline version). and this cannot be used when in Þáappears (actual version is Ü Ýáâã ÝÞß à Ü ÝÞß à ÛFor example, the Meta-PRL thinning rule looks like happens. ÛUsing this frees us from making sure that no name-capture Terms with Alpha-Equality

29 é ë ê è Terms with Alpha-Equality ìa similar idea appears in Scheme macros. ìthe usual problem is unsafe macros that capture names. ìfor example: (defmacro (swap x y) (let ((tmp,x)) (set!,x,y) (set!,y tmp))) ìad-hock solution: (defmacro (swap x y) (let ((tmp (gensym))) (let ((,tmp,x)) (set!,x,y) (set!,y,tmp)))) ìan attempt at a better solution: the hygiene macro system: (define-syntax swap (syntax-rules () ((swap x y) (let ((tmp x)) (set! x y) (set! y tmp))))) ìthis is, however, limited need some primitive system for some things. Eli Barzilay Reflection & Nuprl 28/32

30 î ð ù should be replaced with one-argument ï í Eli Barzilay Reflection & Nuprl 29/32 a binding variable. ñthis makes it even more obvious that can still be regarded as second-order pattern. except that õ ö ø óò ôõ ö ø ùú ÿþýüû ý ü ò ô ú ó ñand when it does: whenódoes not have a free occurrence of, óò ôõ ö ø ùú ÿþýüû ý ü ò ô ú ó ñwe could say things like: ñthis idea can be carried over to a reflected Nuprl. Terms with Alpha-Equality

31 Terms with Alpha-Equality It makes a lot of sense for such ideas to come from an implementation. Meta-PRL s rule specifications are actually a meta-language that specifies Meta-PRL. Using this not only makes writing correct rules easier it also makes writing invalid rules more difficult, similar to the Scheme hygiene macros: impossible to write a macro that captures a name. There will probably not be any need for a lower-level term representation that will not use alpha-equivalence (hopefully). Eli Barzilay Reflection & Nuprl 30/32

32 Final Thoughts... Some more things that will take too much time: In natural language, we can never use an object, just talk about it for example, logic books refer to objects like Lemma 2.5 on page 245. An equivalent of this would be to make the Nuprl library hold quoted objects. (Not practical since it makes it too opaque). Once we have such quoted object any functionality can be reflected as well internal or not. For example, we can talk about,, etc using a rep/unrep wrapper. A quotify operator must be a built-in operation since it is impossible to know the intensional structure of an extensional object (example: quoting Scheme procedures). Eli Barzilay Reflection & Nuprl 31/32

33 The End Related work:? Conclusions: many. Future work: definitely! Eli Barzilay Reflection & Nuprl 32/32