Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Gilles Kahn, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....no reduction under the sign was allowed. This kind of reduction is closely related to reduction of terms in combinatory logic, and we shall present this case in Section 2. Normalization by evaluation for typed lambda calculus with and conversion was invented by Berger and Schwichtenberg [BS91] Initially, they needed a normalization algorithm for their proof system MINLOG, and normalization by evaluation provided a simple solution. Berger then noticed that the NBE program could be extracted from a normalization proof using Tait s method [Ber93] The method has been re ned using ....

.... by evaluation can be exploited for the practical task of type directed partial evaluation (TDPE) Dan98] TDPE is not based on the NBE algorithm for combinators given in the previous section, but on the NBE algorithm returning long normal forms rst presented by Berger and Schwichtenberg [BS91] There are several reasons for this change: Syntax. Most obviously, SK combinators are far from a practical programming language. Although the algorithm extends directly to a more comprehensive set (e.g. SKBCI combinators) we still want to express source programs in a more conventional ....

[Article contains additional citation context not shown here]

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203-211, Amsterdam, The Netherlands, July 1991.

....two rules allows us to coerce the type of any # term to any other type. Eta expansion itself is defined in the third part of our analysis. It is typedirected, and thus it can insert several embedded eta redexes in a way that is reminiscent of Berger and Schwichtenberg s normalization of # terms [2, 7]. Consider the first binding time coercion rule in Figure 1. Intuitively, it works as follows. We are given a # term e that we would like to assign the type # . In Gomard s binding time analysis: x : A(x) # x t 1 ] e : t 2 # w #x.e : t 1 t 2 # #x.w e : d # w #x.e : d # ....

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In LICS'91, Sixth Annual Symposium on Logic in Computer Science, pages 203--211, 1991.

....(into a non standard model) reduction free normalization is also referred to as normalization by evaluation. The flattening example above is folklore in the normalization by evaluation community. Normalization by evaluation has been variously studied in logic, proof theory, and category theory [2, 3, 8 10, 13] and in partial evaluation [14, 16] Typedirected partial evaluation, which we present next, has been investigated both practically [5, 15, 17, 18, 29, 31, 38] and foundationally [24, 25, 47] 1.2 Type directed partial evaluation Type directed partial evaluation is a practical instance of ....

....of functions for each type constructor. The first function, reify, maps a value into a representation of its normal form. The second function, reflect, maps the representation of a normal form into the corresponding value. Reification and reflection are already well described in the literature [8, 10, 16, 25, 28, 29, 31, 38, 47] and therefore, rather than repeating these descriptions, let us instead focus on the one equation of interest: reflection at sum type. t 1 t2 e = shift # in case(e, x.reset(#(in 1 (# t 1 x) y.reset(#(in 2 (# t 2 y) The control operator shift abstracts the evaluation context of t 1 ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Gilles Kahn, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

.... shortcomings of static freshness inference, while at the same time showing off the ease with which highly non trivial syntax manipulating algorithms can be expressed in FreshML Lite; the algorithm in question computes the normal form of an untyped # term (if any) using normalisation by evaluation [15, 4] in a form suggested to us by Thierry Coquand [private communication] In FreshML Lite (augmented with nested patterns and syntax for lists) the function norm has lam (and does indeed compute normal forms where they exist) but in the original version of FreshML with freshness inference norm ....

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In LICS 1991.

....a syntactic term nf : such that nf [ E] nf E] then nf E is a closed term of base type , and can thus be executed as a functional program. This gives us a very ecient executable algorithm for computing normal forms, and was indeed one of the motivations behind the construction [4, 3]: we are reducing the general problem of term normalization to a special case for which we already have a good solution. A natural question arises whether this semantic technique for normalization of lambda terms is inherently tied to conversion. Somewhat surprisingly, it is not: in the ....

....between normalization by evaluation and type directed partial evaluation. Finally, Section 6 concludes and points out some directions for further work. 2 Normalization by evaluation for call by name The normalization construction sketched above, essentially due to Berger and Schwichtenberg [4], has been studied in many formulations [8] including more syntactic variants [2] as well as category theoretic ones [1, 6] In the following, we present it in a call by name functional programming setting [11] this formulation extends particularly naturally to the call by value variant in the ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203-211, Amsterdam, The Netherlands, July 1991.

....the meta level redices yields an object term which corresponds to the long fij normal form of e. For example, if we let S = f:g:x: f x) g x) K = a:b:a then reducing the meta level redices of # ff ff (S K K) yields x:x. This property was first noticed by Berger and Schwichtenberg [5], who exploited it to normalize programs extracted from proofs. They implemented the two level calculus directly in Scheme by letting meta level terms be Scheme values and object level terms be S expressions (i.e. lists) The corresponding two level j expander is displayed in Figure 2. This ....

....it offers pure primitive operators that probe their operands with the usual fixed policy. We also considered that approach in Section 4.5 of our earlier work [17] ffl A native implementation directly processes compiled code. Berger and Schwichtenberg have such an implementation, in Scheme [4, 5]. Filinski does too, in Standard ML, and so do Zhe Yang, also in Standard ML, and Rhiger, in Gofer [34] In the summer of 1997, Balat and Danvy have combined a native implementation with run time code generation, in Caml [3] An ML native implementation cannot offer probing primitive ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

....the trivially specialized program #d.p(s, d) contracting # redexes and eliminating static operations as their inputs become known. What makes this approach attractive is the technique of reduction free normalization or normalization by evaluation , already known from logic and category theory [2, 3, 7]. A few challenges arise, however, with extending these results to a programming language setting. Most notably: Interpreted base types and their associated static operations. These need to be properly accounted for, in addition to the # reduction. Unrestricted recursion. This prevents a ....

....static subcomputations that may cause the whole specialization process to diverge. Example 4 Applying the reification function to the residualizing meaning of a term not in static normal form, we obtain: #x . #f . f ( int (x 1) 2] r ( #f. f ( int (x 1) r (#[x [[2]] r (## ## # . f ( int (x 1) r (#[x val # 2, f d ( int ) C s ( val # 2) val # 1) d ( int ) val # 3) ##.#( # LAM ( #v V . ##.#( LIT int 3) # int#int ( # VARv) # LAM (ARR(BASE int , BASE int ) #v V . # APP ( # VARv) And ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203-- 211, Amsterdam, The Netherlands, July 1991. 21

....inspired by theory, our work is experimental. Indeed, neither the OCaml compiler nor the OCaml virtual machine are formalized. We therefore have not formalized our byte code translator either. As for type directed partial evaluation, only its call by name version has been formalized so far [1, 2, 5]. In that sense our work is experimental: we want to investigate the synergy between type directed partial evaluation and run time code generation for OCaml. 3 1.4 An example: Church numbers Let us illustrate strong normalization by run time code generation to optimize a computation over ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

....d. The combination of the two rules allows us to coerce the type of any term to any other type. Eta expansion itself is defined in Figure 9. It is type directed, and thus it can insert several embedded eta redexes in a way that is reminiscent of Berger and Schwichtenberg s normalization of terms [3, 12]. Consider the first rule in Figure 8. Intuitively, it works as follows. We are given a term e that we would like to assign the type . In case we can only assign it type d and 6= d, we can use the rule to coerce the type to be . The first hypothesis of the rule is that e has type d and ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

....ps into # normal form specializes p with respect to s. For example specializing the K combinator K = # x.# y.x with respect to itself yields # y.# x.# y # .x. TDPE, due to Danvy [6] realizes the above idea using a technique called Normalization by Evaluation (NbE) of Berger and Schwichtenberg [1]. Roughly speaking, NbE works by extracting the normal form of a term from its meaning, where the extraction function is coded in the object language. Example 1. Let PL be a higher order functional language in which we can define a type Exp of term representations. Consider the combinator K = ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Albert R. Meyer, editor, Proceedings of the 6th Annual IEEE Symposium on Logic in Computer Science, pages 203--213, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

....classes of combinators, while keeping the information that needs to be passed on to the partial Godelisers as simple as possible, so as not to trivialise the task of encoding. To the best of our knowledge, the only partial Godeliser in the calculus is due to Berger and Schwichtenberg [2], and encodes simply typed expressions, given an encoding of their type. Given a simply typed expression M of type , we have: G st M (6) In the next section we derive a partial Godeliser for the set of all proper combinators. This result is a part of our Ph.D. thesis [8] 3 ....

....2.1 shows that no Godeliser for exists, that takes no additional information about the expression it is encoding. Consequently, we consider partial Godelisers, operating on specific subsets of and taking some information about the expressions they are encoding. Berger and Schwichtenberg [2] have constructed a partial Godeliser which encodes simply typed expressions, given an encoding of their type. In this paper, we have shown that a partial Godeliser G exists for proper combinators, given their arity. The fact that Godelisation is taken modulo the normal form results in a ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

....G does provably not exist (see section 6.6 of Barendregts book on the lambda calculus [1] Hence, we must relax the condition somewhat. Mayer Goldberg [5] relaxes the condition by restricting the class of terms E that G works for to be the set of proper combinators. Berger and Schwichtenberg [2] relax the condition by requiring E to be in the simply typed lambda calculus and that the type of E is given. Instead of restricting the set of terms that can be Godelised, we want our Godeliser to be able to take any normalizing closed lambda term and return a representation of its normal ....

....match, the third term is selected. Reduction in the extended lambda calculus is strongly believed to be confluent, but at the moment we have not looked at proving this. 3 Godelisation As the basis of our Godeliser we use the Godeliser for the typed lambda calculus by Berger and Schwichtenberg [2], but using a notation similar to the extension of this work found in Danvy s type directed partial evaluators [3] In this, Godelisation is defined by a pair of type indexed functions # t and t , where # t takes a value of type t and produces an expression of type t and t takes an ....

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211. IEEE Computer Society Press, 1991.

....inspired by theory, our work is experimental. Indeed, neither the OCaml compiler nor the OCaml virtual machine are formalized. We therefore have not formalized our byte code translator either. As for typedirected partial evaluation, only its call by name version has been formalized so far [1, 2, 7]. In that sense our work is experimental: we want to investigate the synergy between type directed partial evaluation and run time code generation for OCaml. module ChurchNumbers = struct let cz s z = z let cs n s z = n s (s z) let rec n2cn n = if n=0 then cz else cs (n2cn (n 1) let cn2n n = ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

....and level Demotion lemmas, and the Substitution lemma, are proven in full generality and not just for the cases restricted to values. This development is crucial for a call by name semantics. Such a semantics seems to play an important role in the formal theory of Normalization by Evaluation [1] and Type Directed Partial Evaluation [2] 3. The big step semantics is defined in the style in which fl was defined [3] and does not make explicit use of a stateful renaming function; 4. Terms have no explicit level annotations. Finally, it is straight forward to extend AIM with new base ....

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed --calculus. In Rao Vemuri, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science. IEEE Computer Society Press, Loss Alamitos, 1991.

....set of conversion rules is complete and we even have a decision procedure for it. Indeed if [ M ] and [ N ] are equal, then quote( M ] and quote( N ] are the same and hence M and N are convertible with each other. The normalization function presented in this paper is similar to the one in [2]. In this paper they define a normalization function for simply typed calculus with full fij reduction to obtain a refinement of Friedman s completeness theorem. The main difference compared with their function and ours is that we extend this technique to calculus with explicit contexts and ....

....in the context Gamma associates the corresponding value of the variable in Delta (var val gives the value of this variable) Now the normalization function, nf , is defined as the composition of the evaluation function and quote. This function is similar to the normalization algorithm in [2]; one difference is our use of Kripke models to deal with reduction under . One other difference is that, since we use explicit contexts we can use the context to find the fresh names in the quote function. To compute the normal form is now only to compute the semantics of the term in the ....

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed -calculus. Proceedings of LICS 91.

No context found.

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed {calculus. In R. Vemuri, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science (LICS '91), pages 203{ 211, 1991.

.... rewriting for normalization by evaluation Ulrich Berger, Matthias Eberl and Helmut Schwichtenberg March 29, 2001 Abstract We extend normalization by evaluation (first presented in [5]) from the pure typed calculus to general higher type term rewriting systems and prove its correctness w.r.t. a domain theoretic model. We distinguish between computational rules and proper rewrite rules. The former is a rather restricted class of rules, which, however, allows for a more ....

....however, allows for a more efficient implementation. 1 Introduction It is well known that implementing normalization of terms in the usual recursive fashion is quite inefficient. However, it is possible to compute the long normal form of a term by evaluating it in an appropriate model (cf. [5]) When using for that purpose the built in evaluation mechanism of e.g. Scheme (a pure Lisp dialect) one obtains an amazingly fast algorithm called normalization by evaluation or NbE for short. In the context of type directed partial evaluation [8] it has been analyzed in what sense NbE is ....

[Article contains additional citation context not shown here]

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In R. Vemuri, editor, Proceedings 6'th Symposium on Logic in Computer Science (LICS'91), pages 203--211. IEEE Computer Society Press, Los Alamitos, 1991.

....clear that we can use Scheme evaluation to achieve that. Here our foremost concern is to carry out proofs about programs. Hence we need terms with free variables involving program constants. We want to simplify also such terms, using the same evaluation mechanism as before. This is possible; see [4]. We also want to normalize full proofs. This is possible by the very same mechanism if proofs are written in natural deduction style. Normalization of proofs is an extremely useful tool. It can be thought of as a device that eliminates detours in proofs, and hence presents the proof in a pure, ....

....metalanguage (such as Scheme) in order to compute the normal forms of terms without executing the reduction steps and substitution (which is notoriously inefficient in standard implementations) in particular. 7. 1 Abstract normalization by evaluation For the theoretical background we refer to [4]; a new formalization of normalization by evaluation, extended by term rewriting for constants, will be included, soon. 7.2 Implementation 7.2.1 The model Minlog is implemented in the untyped 1 functional programming language Scheme. Objects of a function space D ae D oe are ....

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed --calculus. In R. Vemuri, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211. IEEE Computer Society Press, Los Alamitos, 1991.

.... rewriting for normalization by evaluation Ulrich Berger, Matthias Eberl and Helmut Schwichtenberg November 2, 1999 Abstract We extend normalization by evaluation (first presented in [5]) from the pure typed calculus to general higher type term rewriting systems. We distinguish between computational rules and proper rewrite rules, and define a domain theoretic model intended to explain why normalization by evaluation for the former is much more efficient. Normalization by ....

....by evaluation is proved to be correct w.r.t. this model. 1 Introduction It is well known that implementing normalization of terms in the usual recursive fashion is quite inefficient. However, it is possible to compute the long normal form of a term by evaluating it in an appropriate model (cf. [5]) When using for that purpose the built in evaluation mechanism of e.g. Scheme (a pure Lisp dialect) one obtains an amazingly fast algorithm called normalization by evaluation or NbE for short; a comparison of its run time with that of more common normalization algorithms can be found in [4, ....

[Article contains additional citation context not shown here]

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed --calculus. In R. Vemuri, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203-- 211. IEEE Computer Society Press, Los Alamitos, 1991.

....mechanism providing an efficient implementation of the operational semantics. Since terms are represented by SCHEME expressions it is quite natural to use SCHEME evaluation instead of explicitly programming a normalization procedure (Berger 10 BENL, BERGER, SCHWICHTENBERG, SEISENBERGER, ZUBER and Schwichtenberg, 1991; Berger, 1993a; Berger et al. 1998) Terms are normalized with respect to conversion and additional higher order rewrite rules given by the user. Correctness and termination of the additional rules are under control of the user. The problem of termination and confluence of higher type rewrite ....

Berger, U. and H. Schwichtenberg: 1991, `An inverse of the evaluation functional for typed --calculus'. In: R. Vemuri (ed.): Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science. pp. 203--211.

No context found.

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Gilles Kahn, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

No context found.

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Gilles Kahn, editor, Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

No context found.

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991.

No context found.

U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed #-calculus. In Proc. of 6th Annual IEEE Symposium on Logic in Computer Science, pages 202--211. IEEE CS Press, 1991.

No context found.

Ulrich Berger and Helmut Schwichtenberg. An inverse of the evaluation functional for typed -calculus. In Proceedings of the Sixth Annual IEEE Symposium on Logic in Computer Science, pages 203--211, Amsterdam, The Netherlands, July 1991. IEEE Computer Society Press.

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC