Results 1  10
of
15
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 17 (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 13 (2 self)
 Add to MetaCart
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 5 (0 self)
 Add to MetaCart
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
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
 Add to MetaCart
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.
Local Organization: Event4 Event Management Preface
, 2007
"... Frameworks and MetaLanguages ” and the MERλIN workshop series on “MEchanized Reasoning about Languages with variable BInding”. Logical frameworks and metalanguages form a common substrate for representing, implementing, and reasoning about a wide variety of deductive systems of interest in logic a ..."
Abstract
 Add to MetaCart
Frameworks and MetaLanguages ” and the MERλIN workshop series on “MEchanized Reasoning about Languages with variable BInding”. Logical frameworks and metalanguages form a common substrate for representing, implementing, and reasoning about a wide variety of deductive systems of interest in logic and computer science. Their design and implementation has been the focus of considerable research over the last two decades, using competing and sometimes incompatible basic principles. This workshop brings together designers, implementors, and practitioners to discuss all aspects of logical frameworks. We received 13 submissions to the workshop of which the committee decided to accept 10. The programme also includes one invited talk by Randy Pollack,
Cycle Therapy: A Prescription For Fold . . .
 IN PROC. 3RD INT'L CONF. PRINCIPLES & PRACTICE DECLARATIVE PROGRAMMING
, 2001
"... Cyclic data structures can be tricky to create and manipulate in declarative programming languages. In a declarative setting, a natural way to view cyclic structures is as denoting regular trees, those trees which may be infinite but have only a finite number of distinct subtrees. This paper shows ..."
Abstract
 Add to MetaCart
Cyclic data structures can be tricky to create and manipulate in declarative programming languages. In a declarative setting, a natural way to view cyclic structures is as denoting regular trees, those trees which may be infinite but have only a finite number of distinct subtrees. This paper shows how to implement the unfold (anamorphism) operator in both eager and lazy languages so as to create cyclic structures when the result is a regular tree as opposed to merely infinite lazy structures. The usual fold (catamorphism) operator when used with a strict combining function on any infinite tree yields an undefined result. As an alternative, this paper defines and show how to implement a cycfold operator with more useful semantics when used with a strict function on cyclic structures representing regular trees. This paper also introduces an abstract data type (cycamores) to simplify the use of cyclic structures representing regular trees in both eager and lazy languages. Implementions of cycamores in both SML and Haskell are presented.