Results 11  20
of
92
Proof Methods for Corecursive Programs
 Fundamenta Informaticae Special Issue on Program Transformation
, 1999
"... This article is a tutorial on four methods for proving properties of corecursive programs: fixpoint induction, the approximation lemma, coinduction, and fusion. ..."
Abstract

Cited by 21 (6 self)
 Add to MetaCart
This article is a tutorial on four methods for proving properties of corecursive programs: fixpoint induction, the approximation lemma, coinduction, and fusion.
Bisimilarity of Open Terms
, 2000
"... Traditionally, in process calculi, relations over open terms, i.e., terms with free process variables, are defined as extensions of closedterm relations: two open terms are related if and only if all their closed instantiations are related. Working in the context of bisimulation, in this paper we s ..."
Abstract

Cited by 20 (0 self)
 Add to MetaCart
Traditionally, in process calculi, relations over open terms, i.e., terms with free process variables, are defined as extensions of closedterm relations: two open terms are related if and only if all their closed instantiations are related. Working in the context of bisimulation, in this paper we study a different approach; we define semantic models for open terms, socalled conditional transition systems, and define bisimulation directly on those models. It turns out that this can be done in at least two different ways, one giving rise to De Simone's formal hypothesis bisimilarity and the other to a variation which we call hypothesispreserving bisimilarity (denoted t fh and t hp, respectively). For open terms, we have (strict) inclusions t fh /t hp / t ci (the latter denoting the standard ``closed instance' ' extension); for closed terms, the three coincide. Each of these relations is a congruence in the usual sense. We also give an alternative characterisation of t hp in terms of nonconditional transitions, as substitutionclosed bisimilarity (denoted t sb). Finally, we study the issue of recursion congruence: we prove that each of the above relations is a congruence with respect to the recursion operator; however, for t ci this result holds under more restrictive conditions than for tfh and thp.]
Relational Reasoning about Contexts
 HIGHER ORDER OPERATIONAL TECHNIQUES IN SEMANTICS, PUBLICATIONS OF THE NEWTON INSTITUTE
, 1998
"... ..."
From SOS Rules to Proof Principles: An Operational Metatheory for Functional Languages
 In Proc. POPL'97, the 24 th ACM SIGPLANSIGACT Symposium on Principles of Programming Languages
, 1997
"... Structural Operational Semantics (SOS) is a widely used formalism for specifying the computational meaning of programs, and is commonly used in specifying the semantics of functional languages. Despite this widespread use there has been relatively little work on the imetatheoryj for such semantics. ..."
Abstract

Cited by 17 (1 self)
 Add to MetaCart
Structural Operational Semantics (SOS) is a widely used formalism for specifying the computational meaning of programs, and is commonly used in specifying the semantics of functional languages. Despite this widespread use there has been relatively little work on the imetatheoryj for such semantics. As a consequence the operational approach to reasoning is considered ad hoc since the same basic proof techniques and reasoning tools are reestablished over and over, once for each operational semantics speciøcation. This paper develops some metatheory for a certain class of SOS language speciøcations for functional languages. We deøne a rule format, Globally Deterministic SOS (gdsos), and establish some proof principles for reasoning about equivalence which are sound for all languages which can be expressed in this format. More speciøcally, if the SOS rules for the operators of a language conform to the syntax of the gdsos format, then ffl a syntactic analogy of continuity holds, which rel...
An abstract dynamic semantics for C
 Computer Laboratory, University of Cambridge
, 1997
"... This report is a presentation of a formal semantics for the C programming language. The semantics has been defined operationally in a structured semantics style and covers the bulk of the core of the language. ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
This report is a presentation of a formal semantics for the C programming language. The semantics has been defined operationally in a structured semantics style and covers the bulk of the core of the language.
From Sequential Programs to MultiTier Applications by Program Transformation
, 2005
"... Modern applications are designed in multiple tiers to separate concerns. Since each tier may run at a separate location, middleware is required to mediate access between tiers. However, introducing this middleware is tiresome and errorprone. ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
Modern applications are designed in multiple tiers to separate concerns. Since each tier may run at a separate location, middleware is required to mediate access between tiers. However, introducing this middleware is tiresome and errorprone.
Reasoning about Functions with Effects
 See Gordon and Pitts
, 1997
"... ing and using (Lunif) we have that any two lambdas that are everywhere undefined are equivalent. The classic example of an everywhere undefined lambda is Bot 4 = x:app(x:app(x; x); x:app(x; x)) In f , another example of an everywhere undefined lambda is the "doforever" loop. Do 4 = f:Yv(Dox ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
ing and using (Lunif) we have that any two lambdas that are everywhere undefined are equivalent. The classic example of an everywhere undefined lambda is Bot 4 = x:app(x:app(x; x); x:app(x; x)) In f , another example of an everywhere undefined lambda is the "doforever" loop. Do 4 = f:Yv(Dox:Do(f(x)) By the recursive definition, for any lambda ' and value v Do(')(v) \Gamma!Ø Do(')('(v)) Reasoning about Functions with Effects 21 In f , either '(v) \Gamma!Ø v 0 for some v 0 or '(v) is undefined. In the latter case the computation is undefined since the redex is undefined. In the former case, the computation reduces to Do(')(v 0 ) and on we go. The argument for undefinedness of Bot relies only on the (app) rule and will be valid in any uniform semantics. In contrast the argument for undefinedness of Do(') relies on the (fred.isdef) property of f . Functional Streams We now illustrate the use of (Lunifsim) computation to reason about streams represented as functions ...
The Generic Approximation Lemma
 Information Processing Letters
, 2001
"... The approximation lemma is a simplification of the wellknown take lemma, and is used to prove properties of programs that produce lists of values. We show how the approximation lemma, unlike the take lemma, can naturally be generalised from lists to a large class of datatypes, and present a gen ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
The approximation lemma is a simplification of the wellknown take lemma, and is used to prove properties of programs that produce lists of values. We show how the approximation lemma, unlike the take lemma, can naturally be generalised from lists to a large class of datatypes, and present a generic approximation lemma that is parametric in the datatype to which it applies. As a useful byproduct, we find that generalising the approximation lemma in this way also simplifies its proof. Keywords: Programming calculi; Functional Programming 1 Introduction The standard proof method for programs that consume lists of values is structural induction. However, this method is not applicable to the dual case of programs that produce lists of values, because in general such programs do not have a list argument over which to perform induction. Proof methods that are applicable to such programs have recently been surveyed in [6], and include fixpoint induction [4], the take lemma [3], coin...
A Proof Tool for Reasoning about Functional Programs
 In Proc. 1996 International Workshop on Higher Order Logic Theorem Proving, Lecture Notes in Computer Science 1125
, 1996
"... . This paper describes a system to support reasoning about lazy functional programs. We describe an approach based on combining a deep embedding of the language in HOL and a set of proof tools to raise the level of interaction with the theorem prover. This approach allows metatheoretic reasoning ab ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
. This paper describes a system to support reasoning about lazy functional programs. We describe an approach based on combining a deep embedding of the language in HOL and a set of proof tools to raise the level of interaction with the theorem prover. This approach allows metatheoretic reasoning about the semantics and reasoning about undefined programs while still supporting practical reasoning about programs in the language. 1 Introduction It is often claimed that functional programming languages, and in particular pure functional languages, are suitable for formal reasoning. This claim is supported by the fact that many people in the functional programming community do reason about their programs in a formal or semiformal way. Depending on the nature of the problem, different styles of reasoning, such as equational reasoning, induction and coinduction, are used. This paper discusses some of the technical issues involved in constructing a proof tool, using HOL [4], for reasoning ...