Sergei A. Romanenko

Arity Raiser and its Use in Program Specialization

Experiments on generating compilers by specializing specializers with respect to interpreters have shown that the compilers thus obtained have a natural structure only if the specializer does variable splitting. Variable splitting can result in a residual program using several variables to represent the values of a single variable of the original program. In the case of functional programming variable splitting is done by raising the arities of functions. The paper describes the structure and principles of operation of an arity raiser dealing with programs in a subset of pure Lisp.

Proving the equivalence of higher-order terms by means of supercompilation

One of the applications of supercompilation is proving properties of programs. We focus in this paper on a specific task: proving term equivalence for a higher-order lazy functional language. The “classical” way to prove equivalence of two terms t1 and t2 is to write an equality function equals and to simplify the term (equals t1 t2). However, this works only when certain conditions are met. The paper presents another approach to proving term equivalence by means of supercompilation. In this approach we supercompile both terms and compare supercompiled terms syntactically. Some applications of the technique are discussed. In particular, one of these applications may lead to the development of a more powerful “higher-level” supercompiler.

Multi-result supercompilation as branching growth of the penultimate level in metasystem transitions

The paper deals with some aspects of metasystem transi- tions in the context of supercompilation. We consider the manifestations of the law of branching growth of the penultimate level in the case of higher-level supercompilation and argue that this law provides some use- ful hints regarding the ways of constructing metasystems by combining supercompilers. In particular we show the usefulness of multi-result su- percompilation for proving the equivalence of expressions and in two-level supercompilation.

Partial Evaluation for Common Intermediate Language

Partial Evaluation is a well-established method for specialization of programs in functional languages. However, real-world applications demand specialization of object-oriented languages. With the advent of the Microsoft .NET platform with Common Intermediate Language (CIL), to which multiple languages are compiled, various program analysis and transformation techniques, including partial evaluation, can be developed once for a low-level language rather than over and over again to various high-level languages. The CILPE Project aims at developing a practical specializer for CIL programs based on Partial Evaluation with preliminary analysis referred to as Binding Time Analysis (BTA). The CILPE Specializer partially evaluates operations on values and objects determined by BTA as static. Static objects are created, processed and destroyed at specialization time; they may be mutable and can have some fields unknown (dynamic). Arbitrary verifiable CIL code is allowed as input.

Supercompilation for Martin-Lof's type theory

This paper describes the design and implementation of a TT Lite certifying supercompiler, which transforms a source program into a pair consisting of a residual program and a proof that the residual program is equivalent to the source one. As far as we can judge from the presently available literature, it is the first time that certifying supercompilation is implemented for a nontrivial higher-order functional language. Proofs generated by the TT Lite supercompiler can be verified by the type checker that does not depend on the supercompiler and is not based on supercompilation. This is especially important when reliability of results obtained by means of supercompilation is of primary concern.

Certifying Supercompilation for Martin-Löf’s Type Theory

The paper describes the design and implementation of a certifying supercompiler TT Lite SC, which takes an input program and produces a residual program and a proof of the fact that the residual program is equivalent to the input one. As far as we can judge from the literature, this is the first implementation of a certifying supercompiler for a non-trivial higher-order functional language. The proofs generated by TT Lite SC can be verified by a type checker which is independent from TT Lite SC and is not based on supercompilation. This is essential in cases where the reliability of results obtained by supercompilation is of fundamental importance. Currently, the proofs can be either verified by the type-checker built into TT Lite, or converted into Agda programs and checked by the Agda system. The main technical contribution is a simple but intricate interplay of supercompilation and type theory.

Higher-level supercompilation as a metasystem transition

Issues related to metasystem transitions in the context of supercompilation are discussed. Manifestations of the law of branching growth of the penultimate level in the case of higher-level supercompilation are considered. Based on this law, some approaches to the construction of metasystems by combining supercompilers are proposed. In particular, the usefulness of multi-result supercompilation for proving the equivalence of expressions and for two-level supercompilation is shown.