Results 1  10
of
42
Higherorder logic programming
 HANDBOOK OF LOGIC IN AI AND LOGIC PROGRAMMING, VOLUME 5: LOGIC PROGRAMMING. OXFORD (1998
"... ..."
An Introduction to Partial Evaluation
 ACM Computing Surveys
, 1996
"... Partial evaluation provides a unifying paradigm for a broad spectrum of work in ..."
Abstract

Cited by 134 (0 self)
 Add to MetaCart
Partial evaluation provides a unifying paradigm for a broad spectrum of work in
Reasoning with higherorder abstract syntax in a logical framework
 ACM Transactions on Computational Logic
, 2002
"... Logical frameworks based on intuitionistic or linear logics with highertype quantification have been successfully used to give highlevel, modular, and formal specifications of many important judgments in the area of programming languages and inference systems. Given such specifications, it is natu ..."
Abstract

Cited by 90 (23 self)
 Add to MetaCart
Logical frameworks based on intuitionistic or linear logics with highertype quantification have been successfully used to give highlevel, modular, and formal specifications of many important judgments in the area of programming languages and inference systems. Given such specifications, it is natural to consider proving properties about the specified systems in the framework: for example, given the specification of evaluation for a functional programming language, prove that the language is deterministic or that evaluation preserves types. One challenge in developing a framework for such reasoning is that higherorder abstract syntax (HOAS), an elegant and declarative treatment of objectlevel abstraction and substitution, is difficult to treat in proofs involving induction. In this paper, we present a metalogic that can be used to reason about judgments coded using HOAS; this metalogic is an extension of a simple intuitionistic logic that admits higherorder quantification over simply typed λterms (key ingredients for HOAS) as well as induction and a notion of definition. The latter concept of definition is a prooftheoretic device that allows certain theories to be treated as “closed ” or as defining fixed points. We explore the difficulties of formal metatheoretic analysis of HOAS encodings by considering encodings of intuitionistic and linear logics, and formally derive the admissibility of cut for important subsets
Modeling an algebraic stepper
 Proceedings of the 10th European Symposium on Programming, volume 2028 of Lecture Notes in Computer Science
, 2001
"... Abstract. Programmers rely on the correctness of the tools in their programming environments. In the past, semanticists have studied the correctness of compilers and compiler analyses, which are the most important tools. In this paper, we make the case that other tools, such as debuggers and stepper ..."
Abstract

Cited by 43 (17 self)
 Add to MetaCart
Abstract. Programmers rely on the correctness of the tools in their programming environments. In the past, semanticists have studied the correctness of compilers and compiler analyses, which are the most important tools. In this paper, we make the case that other tools, such as debuggers and steppers, deserve semantic models, too, and that using these models can help in developing these tools. Our concrete starting point is the algebraic stepper in DrScheme, our Scheme programming environment. The algebraic stepper explains a Scheme computation in terms of an algebraic rewriting of the program text. A program is rewritten until it is in a canonical form (if it has one). The canonical form is the final result. The stepper operates within the existing evaluator, by placing breakpoints and by reconstructing source expressions from source information placed on the stack. This approach raises two questions. First, do the runtime breakpoints correspond to the steps of the reduction semantics? Second, does the debugging mechanism insert enough information to reconstruct source expressions? To answer these questions, we develop a highlevel semantic model of the extended compiler and runtime machinery. Rather than modeling the evaluation as a lowlevel machine, we model the relevant lowlevel features of the stepper’s implementation in a highlevel reduction semantics. We expect the approach to apply to other semanticsbased tools. 1 The Correctness of Programming Environment Tools Programming environments provide many tools that process programs semantically. The most common ones are compilers, program analysis tools, debuggers, and profilers. Our DrScheme programming environment [9,8] also provides an algebraic stepper for Scheme. It explains a program’s execution as a sequence of reduction steps based on the ordinary laws of algebra for the functional core [2,
Higherorder abstract syntax in Coq
, 1995
"... The terms of the simplytyped λcalculus can be used to express the higherorder abstract syntax of objects such as logical formulas, proofs, and programs. Support for the manipulation of such objects is provided in several programming languages (e.g. λProlog, Elf). Such languages also provide embed ..."
Abstract

Cited by 41 (1 self)
 Add to MetaCart
The terms of the simplytyped λcalculus can be used to express the higherorder abstract syntax of objects such as logical formulas, proofs, and programs. Support for the manipulation of such objects is provided in several programming languages (e.g. λProlog, Elf). Such languages also provide embedded implication, a tool which is widely used for expressing hypothetical judgments in natural deduction. In this paper, we show how a restricted form of secondorder syntax and embedded implication can be used together with induction in the Coq Proof Development system. We specify typing rules and evaluation for a simple functional language containing only function abstraction and application, and we fully formalize a proof of type soundness in the system. One difficulty we encountered is that expressing the higherorder syntax of an objectlanguage as an inductive type in Coq generates a class of terms that contains more than just those that directly represent objects in the language. We ove...
Compilation and Equivalence of Imperative Objects
, 1998
"... We adopt the untyped imperative object calculus of Abadi and Cardelli as a minimal setting in which to study problems of compilation and program equivalence that arise when compiling objectoriented languages. We present both a bigstep and a smallstep substitutionbased operational semantics fo ..."
Abstract

Cited by 34 (4 self)
 Add to MetaCart
We adopt the untyped imperative object calculus of Abadi and Cardelli as a minimal setting in which to study problems of compilation and program equivalence that arise when compiling objectoriented languages. We present both a bigstep and a smallstep substitutionbased operational semantics for the calculus. Our rst two results are theorems asserting the equivalence of our substitutionbased semantics with a closurebased semantics like that given by Abadi and Cardelli. Our third result is a direct proof of the correctness of compilation to a stackbased abstract machine via a smallstep decompilation algorithm. Our fourth result is that contextual equivalence of objects coincides with a form of Mason and Talcott's CIU equivalence; the latter provides a tractable means of establishing operational equivalences. Finally, we prove correct an algorithm, used in our prototype compiler, for statically resolving method osets. This is the rst study of correctness of an objectoriented abstract machine, and of operational equivalence for the imperative object calculus.
A Functional Correspondence between CallbyNeed Evaluators and Lazy Abstract Machines
, 2004
"... ..."
Encoding Transition Systems in Sequent Calculus
 Theoretical Computer Science
, 1996
"... Intuitionistic and linear logics can be used to specify the operational semantics of transition systems in various ways. We consider here two encodings: one uses linear logic and maps states of the transition system into formulas, and the other uses intuitionistic logic and maps states into terms. I ..."
Abstract

Cited by 33 (10 self)
 Add to MetaCart
Intuitionistic and linear logics can be used to specify the operational semantics of transition systems in various ways. We consider here two encodings: one uses linear logic and maps states of the transition system into formulas, and the other uses intuitionistic logic and maps states into terms. In both cases, it is possible to relate transition paths to proofs in sequent calculus. In neither encoding, however, does it seem possible to capture properties, such as simulation and bisimulation, that need to consider all possible transitions or all possible computation paths. We consider augmenting both intuitionistic and linear logics with a proof theoretical treatment of definitions. In both cases, this addition allows proving various judgments concerning simulation and bisimulation (especially for noetherian transition systems). We also explore the use of infinite proofs to reason about infinite sequences of transitions. Finally, combining definitions and induction into sequent calculus proofs makes it possible to reason more richly about properties of transition systems completely within the formal setting of sequent calculus.
Functional BackEnds within the LambdaSigma Calculus
, 1996
"... We define a weak calculus, oe w , as a subsystem of the full calculus with explicit substitutions oe * . We claim that oe w could be the archetypal output language of functional compilers, just as the calculus is their universal input language. Furthermore, oe * could be the adequate theory to e ..."
Abstract

Cited by 20 (0 self)
 Add to MetaCart
We define a weak calculus, oe w , as a subsystem of the full calculus with explicit substitutions oe * . We claim that oe w could be the archetypal output language of functional compilers, just as the calculus is their universal input language. Furthermore, oe * could be the adequate theory to establish the correctness of simplified functional compilers. Here, we illustrate these claims by proving the correctness of four simplified compilers and runtime systems modeled as abstract machines. The four machines we prove are the Krivine machine, the SECD, the FAM and the CAM. Thereby, we give the first formal proofs of Cardelli's FAM and of its compiler.