Results 1 
9 of
9
Plogic: property verification for Haskell programs
, 2002
"... Proofsupported logical verification of program properties has been a topic of research interest for more than 30 years. The feasibility of proof construction as a verification technique has been demonstrated through many examples of its application, yet it remains a technique rarely used in prac ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
Proofsupported logical verification of program properties has been a topic of research interest for more than 30 years. The feasibility of proof construction as a verification technique has been demonstrated through many examples of its application, yet it remains a technique rarely used in practice for a variety of reasons, both technical and sociological. The lack of verification logics for modern programming languages remains a strong deterrent to the use of proofsupported verification.
A constructive approach to language definition
 Journal of Universal Computer Science
, 2005
"... Abstract: Most approaches to formal semantics are based on the assumption that all the constructs of a language are defined together. The details of the definition of each construct can (and usually do) depend on which other constructs are included in the given language. This limits reuse of definit ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
Abstract: Most approaches to formal semantics are based on the assumption that all the constructs of a language are defined together. The details of the definition of each construct can (and usually do) depend on which other constructs are included in the given language. This limits reuse of definitions of common constructs. programming construct is defined separately and independently. The semantics of a full language is obtained by translating its constructs into the basic abstract constructs, whose definitions are thus reused verbatim. The frameworks of Modular SOS and Action Semantics can both be used in conjunction with the proposed approach. Some illustrations are given. Key Words: semantics of programming languages, action semantics, structural operational semantics, modularity
HOLCF ’11: A Definitional Domain Theory for Verifying Functional Programs
, 2012
"... HOLCF is an interactive theorem proving system that uses the mathematics of domain theory to reason about programs written in functional programming languages. This thesis introduces HOLCF ’11, a thoroughly revised and extended version of HOLCF that advances the state of the art in program verificat ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
HOLCF is an interactive theorem proving system that uses the mathematics of domain theory to reason about programs written in functional programming languages. This thesis introduces HOLCF ’11, a thoroughly revised and extended version of HOLCF that advances the state of the art in program verification: HOLCF ’11 can reason about many program definitions that are beyond the scope of other formal proof tools, while providing a high degree of proof automation. The soundness of the system is ensured by adhering to a definitional approach: New constants and types are defined in terms of previous concepts, without introducing new axioms. Major features of HOLCF ’11 include two highlevel definition packages: the Fixrec package for defining recursive functions, and the Domain package for defining recursive datatypes. Each of these uses the domaintheoretic concept of least fixed points to translate usersupplied recursive specifications into safe lowlevel definitions. Together, these tools make it easy for users to translate a wide variety of functional programs into the formalism of HOLCF. Theorems generated by the tools also make it easy for users to reason about their programs, with a very high level of confidence in the soundness of the results. As a case study, we present a fully mechanized verification of a model of concurrency based on powerdomains. The formalization depends on many features unique to HOLCF ’11, and is the first verification of such a model in a formal proof tool. ii ACKNOWLEDGMENTS I would like to thank my advisor, John Matthews, for having continued to devote so much time to working with me, even as a parttime professor; and for motivating me to keep studying domain theory (and enjoying it!) these past years. iii
A Simple Semantics for Polymorphic Recursion
 Lecture Notes in Computer Science
, 2005
"... Polymorphic recursion is a useful extension of HindleyMilner typing and has been incorporated in the functional programming language Haskell. It allows the expression of efficient algorithms that take advantage of nonuniform data structures and provides key support for generic programming. However ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Polymorphic recursion is a useful extension of HindleyMilner typing and has been incorporated in the functional programming language Haskell. It allows the expression of efficient algorithms that take advantage of nonuniform data structures and provides key support for generic programming. However, polymorphic recursion is, perhaps, not as broadly understood as it could be and this, in part, motivates the denotational semantics presented here. The semantics reported here also contributes an essential building block to any semantics of Haskell: a model for firstorder polymorphic recursion. Furthermore, Haskellstyle type classes may be described within this semantic framework in a straightforward and intuitively appealing manner.
Automated soundness checking of a programming logic for Haskell
"... Haskell. Inference rules are expressed in sequent calculus for each of the term constructs of Haskell. Validating soundness of these rules is an essential task. Most rules of Plogic are polymorphic, independent of Haskell's type classes. The paper develops a parametricity principle for predicates o ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Haskell. Inference rules are expressed in sequent calculus for each of the term constructs of Haskell. Validating soundness of these rules is an essential task. Most rules of Plogic are polymorphic, independent of Haskell's type classes. The paper develops a parametricity principle for predicates of Plogic, which justifies checking soundness of polymorphic rules at a particular type instance. By implementing the Haskell semantics with a metacircular interpreter, automated modelchecking has been used to validate soundness of the polymorphic inference rules of Plogic.
Reasoning about Selective Strictness  Operational Equivalence, Heaps and CallbyNeed Evaluation, New Inductive Principles
, 2009
"... Many predominantly lazy languages now incorporate strictness enforcing primitives, for example a strict let or sequential composition seq. Reasons for doing this include gains in time or space efficiencies, or control of parallel evaluation. This thesis studies how to prove equivalences between pro ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Many predominantly lazy languages now incorporate strictness enforcing primitives, for example a strict let or sequential composition seq. Reasons for doing this include gains in time or space efficiencies, or control of parallel evaluation. This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq whose operational semantics is a variant of one considered by van Eckelen and de Mol, which itself was derived from Launchbury’s natural semantics for lazy evaluation. The main research contributions are as follows: We establish some of the first ever equivalences between programs with selective strictness. We do this by manipulating operational semantics derivations, in
Abstract Patterndriven Reduction in Haskell
"... Haskell is a functional programming language with nominally nonstrict semantics, implying that evaluation of a Haskell expression proceeds by demanddriven reduction. However, Haskell also provides pattern matching on arguments of functions, in let expressions and in the match clauses of case expre ..."
Abstract
 Add to MetaCart
Haskell is a functional programming language with nominally nonstrict semantics, implying that evaluation of a Haskell expression proceeds by demanddriven reduction. However, Haskell also provides pattern matching on arguments of functions, in let expressions and in the match clauses of case expressions. Patternmatching requires datadriven reduction to the extent necessary to evaluate a pattern match semantics and a logical characterization of patternmatching in Haskell and the reduction order that it entails. 1
Towards Semanticsdirected System Design and Synthesis
"... Abstract — High assurance systems have been defined as systems “you would bet your life on. ” This article discusses the application of a form of functional programming— what we call “monadic programming”—to the generation of high assurance and secure systems. Monadic programming languages leverage ..."
Abstract
 Add to MetaCart
Abstract — High assurance systems have been defined as systems “you would bet your life on. ” This article discusses the application of a form of functional programming— what we call “monadic programming”—to the generation of high assurance and secure systems. Monadic programming languages leverage algebraic structures from denotational semantics and functional programming—monads—as a flexible, modular organizing principle for secure system design and implementation. Monadic programming languages are domainspecific functional languages that are both sufficiently expressive to express essential system behaviors and semantically straightforward to support formal verification. Fig. 1: A separation kernel mediates all interdomain communication, thereby enforcing its security policy. The dotted arrow designates permitted information flows.
Reasoning about Selective Strictness  Operational Equivalence, Heaps and CallbyNeed Evaluation, New Inductive Principles
, 2009
"... This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq. We establish some of the first ever equivalences between lazy programs with selective str ..."
Abstract
 Add to MetaCart
This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq. We establish some of the first ever equivalences between lazy programs with selective strictness by manipulating operational semantics derivations. Our operational semantics is similar to that used by van Eekelen and De Mol, though we introduce a ‘garbagecollecting’ rule for (let) which turns out to cause expressiveness restrictions. For example, arguably reasonable lazy programs such as let y = λz.z in λx.y do not reduce in our operational semantics. We prove some properties of seq, including associativity, idempotence, and leftcommutativity. The proofs use our three notions of program equivalence defined