Results 1  10
of
18
Types for Modules
, 1998
"... The programming language Standard ML is an amalgam of two, largely orthogonal, languages. The Core language expresses details of algorithms and data structures. The Modules language expresses the modular architecture of a software system. Both languages are statically typed, with their static and dy ..."
Abstract

Cited by 80 (13 self)
 Add to MetaCart
The programming language Standard ML is an amalgam of two, largely orthogonal, languages. The Core language expresses details of algorithms and data structures. The Modules language expresses the modular architecture of a software system. Both languages are statically typed, with their static and dynamic semantics specified by a formal definition.
Inductive Graphs and Functional Graph Algorithms
, 2001
"... We propose a new style of writing graph algorithms in functional languages which is based on an alternative view of graphs as inductively defined data types. We show how this graph model can be implemented efficiently, and then we demonstrate how graph algorithms can be succinctly given by recursive ..."
Abstract

Cited by 22 (2 self)
 Add to MetaCart
We propose a new style of writing graph algorithms in functional languages which is based on an alternative view of graphs as inductively defined data types. We show how this graph model can be implemented efficiently, and then we demonstrate how graph algorithms can be succinctly given by recursive function definitions based on the inductive graph view. We also regard this as a contribution to the teaching of algorithms and data structures in functional languages since we can use the functionalstyle graph algorithms instead of the imperative algorithms that are dominant today. Keywords: Graphs in Functional Languages, Recursive Graph Algorithms, Teaching Graph Algorithms in Functional Languages
A formal calculus for informal equality with binding
 In WoLLIC’07: 14th Workshop on Logic, Language, Information and Computation, volume 4576 of LNCS
, 2007
"... Abstract. In informal mathematical usage we often reason using languages with binding. We usually find ourselves placing captureavoidance constraints on where variables can and cannot occur free. We describe a logical derivation system which allows a direct formalisation of such assertions, along w ..."
Abstract

Cited by 19 (7 self)
 Add to MetaCart
(Show Context)
Abstract. In informal mathematical usage we often reason using languages with binding. We usually find ourselves placing captureavoidance constraints on where variables can and cannot occur free. We describe a logical derivation system which allows a direct formalisation of such assertions, along with a direct formalisation of their constraints. We base our logic on equality, probably the simplest available judgement form. In spite of this, we can axiomatise systems of logic and computation such as firstorder logic or the lambdacalculus in a very direct and natural way. We investigate the theory of derivations, prove a suitable semantics sound and complete, and discuss existing and future research. 1
A Functional Language for Logarithmic Space
 In APLAS
, 2004
"... More than being just a tool for expressing algorithms, a welldesigned programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore of importance to understand how such choices effe ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
(Show Context)
More than being just a tool for expressing algorithms, a welldesigned programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore of importance to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a firstorder function algebra BC # that captures exactly LF, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. Moreover, it can be useful for the automatic analysis of programs' resource usage and the separation of complexity classes. The important technical features of BC # are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (courseofvalue recursion). Unlike formulations LF via Turin Machines, BC # makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LFcomputable functions (not just predicates). The proof that all BC #programs can be evaluated in LF is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.
An Engineering Approach to Atomic Transaction Verification: Use of a Simple Object Model to Achieve Semanticsbased Reasoning at Compiletime
 University of Twente
, 1998
"... In this paper, we take an engineering approach to atomic transaction verification. We discuss the design and implementation of a verification tool that can reason about the semantics of atomic database operations. To bridge the gap between language design and automated reasoning, we make use of a ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
In this paper, we take an engineering approach to atomic transaction verification. We discuss the design and implementation of a verification tool that can reason about the semantics of atomic database operations. To bridge the gap between language design and automated reasoning, we make use of a simple model of objects that imitates the typetagged memory structure of an implementation. This simple model is sufficient to describe the operational semantics of the typical features of an objectoriented database programming language, such as bounded iteration, heterogeneity, object creation, and nil values. The same model lends itself to automated reasoning with a theorem prover system. We are thus able to apply theorem prover technology to verification problems that address transaction semantics. The work has applications in the areas of transaction safety, semanticsbased concurrency control, and cooperative work. The approach is illustrated by a graph editing example, with heterogeneous node structures.
A nominal axiomatisation of the lambdacalculus
"... The lambdacalculus is a fundamental syntax in computer science. It resists an algebraic treatment because of captureavoidance sideconditions. Nominal algebra is a logic of equality designed with formalisation of specifications involving binding in mind. In this paper we axiomatise the lambdacalc ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
The lambdacalculus is a fundamental syntax in computer science. It resists an algebraic treatment because of captureavoidance sideconditions. Nominal algebra is a logic of equality designed with formalisation of specifications involving binding in mind. In this paper we axiomatise the lambdacalculus using nominal algebra, demonstrate how proofs with these axioms reflect the informal arguments on syntax, and we prove the axioms sound and complete. This makes a formal connection between a ‘nominal’ approach to variables, and the more traditional view of variables as a syntactic convenience for describing functions.
The lambdacontext calculus
 In: LFMTP’07: International Workshop on Logical Frameworks and MetaLanguages
"... We present a simple lambdacalculus whose syntax is populated by variables which behave like metavariables. It can express both captureavoiding and capturing substitution (instantiation). To do this requires several innovations, including a key insight in the confluence proof and a set of reductio ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We present a simple lambdacalculus whose syntax is populated by variables which behave like metavariables. It can express both captureavoiding and capturing substitution (instantiation). To do this requires several innovations, including a key insight in the confluence proof and a set of reduction rules which manages the complexity of a calculus of contexts over the ‘vanilla ’ lambdacalculus in a very simple and modular way. This calculus remains extremely close in look and feel to a standard lambdacalculus with explicit substitutions, and good properties of the lambdacalculus are preserved. These include a HindleyMilner type system with principal typings and subject reduction, and an applicative characterisation of contextual equivalence. Key words: Lambdacalculus, calculi of contexts, functional programming,
Model Analysis via a Translation Schema to Coloured Petri
"... Abstract. Modeldriven development (MDD) has become a success story and a de facto standard in the development of safetycritical embedded systems. The daily work in the development of such systems cannot be imagined without industry standard CASE tools like e.g. MATLAB/Simulink. Often however, the ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Modeldriven development (MDD) has become a success story and a de facto standard in the development of safetycritical embedded systems. The daily work in the development of such systems cannot be imagined without industry standard CASE tools like e.g. MATLAB/Simulink. Often however, the analysis capabilities of such tools are limited. Therefore, we propose to combine them with the powerful analysis tools developed for Coloured Petri Nets (CPNs). In this paper, we present a translation schema from COLA—a synchronous dataflow language—to CPNs. We believe this approach to be also feasible for other dataflow languages as long as they have a welldefined syntax and semantics. The combination of both modelling languages allows us to verify properties of COLA models using algorithms and tools designed for CPNs. An example demonstrates the viability of this approach.
Amalgamation in the Semantics of CASL
"... We present a semantics for architectural specifications in Casl, including an extended static analysis compatible with modeltheoretic requirements. The main obstacle here is the lack of amalgamation for Casl models. To circumvent this problem, we extend the Casl logic by introducing enriched signat ..."
Abstract
 Add to MetaCart
We present a semantics for architectural specifications in Casl, including an extended static analysis compatible with modeltheoretic requirements. The main obstacle here is the lack of amalgamation for Casl models. To circumvent this problem, we extend the Casl logic by introducing enriched signatures, where subsort embeddings form a category rather than just a preorder. The extended model functor satisfies the amalgamation property as well as its converse, which makes it possible to express the amalgamability conditions in the semantic rules in static terms. Using these concepts, we develop the semantics at various levels in an institutionindependent fashion. Moreover, amalgamation for enriched Casl means that a variety of results for institutions with amalgamation, such as computation of normal forms and theorem proving for structured specifications, can now be used for Casl.