Electronic Notes in Theoretical Computer Science

Published by Elsevier
Print ISSN: 1571-0661
Process modeling languages such as "Dynamical Grammars" are highly expressive in the processes they model using stochastic and deterministic dynamical systems, and can be given formal semantics in terms of an operator algebra. However such process languages may be more limited in the types of objects whose dynamics is easily expressible. For many applications in biology, the dynamics of spatial objects in particular (including combinations of discrete and continuous spatial structures) should be formalizable at a high level of abstraction. We suggest that this may be achieved by formalizing such objects within a type system endowed with type constructors suitable for complex dynamical objects. To this end we review and illustrate the operator algebraic formulation of heterogeneous process modeling and semantics, extending it to encompass partial differential equations and intrinsic graph grammar dynamics. We show that in the operator approach to heterogeneous dynamics, types require integration measures. From this starting point, "measurable" object types can be enriched with generalized metrics under which approximation can be defined. The resulting measurable and "metricated" types can be built up systematically by type constructors such as vectors, products, and labelled graphs. We find conditions under which functions and quotients can be added as constructors of measurable and metricated types.
This paper summarizes our experience with IF, an open validation environment for distributed software systems. Indeed, face to the increasing complexity of such systems, none of the existing tools can cover by itself the whole validation process. The IF environment was built upon an expressive intermediate language and allows to connect several validation tools, providing most of the advanced techniques currently available. The results obtained on several large case-studies, including telecommunication protocols and embedded software systems, confirm the practical interest of this approach
We present pmlB, a programming language that includes primitive sets and associated operations. The language is equipped with a precise type discipline that statically captures dynamic properties of sets, allowing runtime optimizations. We demonstrate the utility of pmlB by showing how it can serve as a practical implementation language for higher-level programming language based security systems, and characterize pmlB by comparing the expressiveness of pmlB sets with enumerations. 1 Introduction In this paper we present the pmlB programming language, which includes primitive records, sets, and associated operations, as well as a static type discipline that provides accurate specifications of these constructs. We demonstrate how pmlB can serve as a practical implementation language for higherlevel language features that can be encoded in terms of sets and records; in particular, the type discipline of pmlB allows dynamic set manipulation and membership checks to be captured statically, which in turn allows runtime optimizations. There are a wide array of set-based properties in languages studied today, so there are multiple applications of pmlB.
When a group of people are thinking about some true formula A, one of them may know it, all of them may know it, or it might be common knowledge. But there are also many other possible states of knowledge and they can change when communication takes place. What states of knowledge are possible? What is the dynamics of such changes? And how do they affect possible co-ordinated action? We describe some developments in this domain.
We discuss coverage checking for data that is dependently typed and is defined using higher-order abstract syntax. Unlike previous work on coverage checking for closed data, we consider open data which may depend on some context. Our work may therefore provide insight into coverage checking in Twelf, and serve as a basis for coverage checking in functional languages such as Delphin and Beluga. More generally, our work is a foundation for proofs by case analysis in systems that reason about higher-order abstract syntax.
If S = 0 is a system of n equations and unknowns over C and S(α) = 0 to what extent can we compute with the point α? In particular, can we decide whether or not a polynomial expressions in the components of α with integral coefficients is zero? This question is considered for both algebraic and elementary systems of equations.
In this work we provide a semantic description of functional logic languages covering notions like laziness, sharing, and non-determinism. Such a semantic description is essential, for instance, to have appropriate language definitions in order to reason about programs and check the correctness of implementations. First, we define a “big-step” semantics in natural style to relate expressions and their evaluated results. Since this semantics is not sufficient to reason about the operational aspects of programs, we also define a “small-step” operational semantics covering the main features of functional logic languages. Finally, we demonstrate the equivalence of the “small-step” semantics and the natural semantics.
We present a Globally Asynchronous Locally Synchronous test chip fabricated on a 130nm silicon process. The primary design goals of this chip were to measure the stability of local clocks on a deep submicron process technology, evaluate difficulties using GALS in a standard design flow, and to measure power consumption. The original Asynchronous Wrapper building blocks were used to construct a configurable data pipeline that can be tuned to emulate the operation of many different types of algorithms.
The HLCL workshops are intended to bring together researchers involved in the design, development, foundations, and applications of high-level concurrent programming languages and models.Programming models should be simple, practical, high-level, and well founded. These qualities allow rigorous language specifications and support both formal and informal reasoning about programs. For concurrent and distributed systems, research on programming models has driven the design of several recent programming languages, including Erlang, versions of ML, like CML, Facile, and Haskell, as well as languages explicitly designed for concurrency or distribution such as Obliq, Oz, Pict, and the Join-Calculus language. Although the motivations behind the design of these languages are diverse (ranging from the development of graphical user interfaces and multi-agent systems to constraint, real-time, and distributed programming), suitable foundations have turned out to be quite similar in style and technique, often based on variants of well-known calculi for mobile processes.The first HLCL Workshop was organized by Benjamin Pierce and Matthew Hennessy at the Isaac Newton Institute for Mathematical Sciences, University of Cambridge, UK, in October 1995. The second HLCL Workshop was organized by Martin Müller and Joachim Niehren at Dagstuhl, Germany, in January 1997, chaired by Kohei Honda, Martin Odersky, Benjamin Pierce, Gert Smolka, and Phil Wadler. For more information see the workshop homepage.In addition to the six contributed papers presented at the workshop, this collection contains an abstract of the invited talk by James E. White (General Magic, US). We would like to thank the authors of the submitted papers, the invited speaker, and the members of the program committee for their contribution to both the meeting and this volume. We also would like to thank BRICS for the printing and Michael Mislove for his help with the editing of the proceedings, ERCIM for financial support, the CONCUR organizing committee at INRIA for hosting HLCL'98, and Silvano Dal-Zilio for further local organization.
This paper relates labeled transition systems and coalgebras with the motivation of comparing and combining their complementary contributions to the theory of concurrent systems. The well-known mismatch between these two notions for what concerns the morphisms is resolved by extending the coalgebraic framework by lax cohomomorphisms.Enriching both labeled transition systems and coalgebras with algebraic structure for an algebraic specification, the correspondence is lost again. This leads to the introduction of lax coalgebras, where the coalgebra structure is given by a lax homomorphism. The resulting category of lax coalgebras and lax cohomomorphisms for a suitable endofunctor is shown to be isomorphic to the category of structured transition systems, where both states and transitions form algebras.The framework is also presented on a more abstract categorical level using monads and comonads, extending the bialgebraic approach recently introduced by Turi and Plotkin.
Consultation and delegation mechanisms.
Examples of class hierarchies with Dec-Java.
Class inheritance and dynamic binding are the key features of object-oriented programming and they permit designing and developing complex systems. However, standard class inheritance is essentially static and cannot be directly employed for modeling dynamic object behaviors. In this paper we propose a linguistic extension of Java, called Dec-Java, that is partially inspired by the decorator design pattern. This extension permits easily separating the basic features of objects (that are likely not to change during the application) from their behaviors (that, instead, can be composed dynamically at run-time). Thus, Dec-Java enables a dynamic extension and specialization of object responsibilities.
And/or tree for the car radio
Variant occurrences within an interaction
Interaction for the negotiation of an order
Means for the representation of variability in UML 2.0 interactions, as presented in a previous work, are further formalised and given a mathematically formal semantics. In this way, UML 2.0 interactions can be used in the conception and development of system families within domain and application engineering tasks. Following the transition from domain to application engineering as a configuration endeavour, resolution of the variability according to a given configuration is captured by a denotational semantics for plain interactions extended to the features for the specification of variability. An example based on a previous case study explicates the semantics hereby defined.
One of the major changes in going from UML 1.5 to UML 2.0 is the reengineering of activity diagrams. This paper examines activity diagramies as described in the current version of the UML 2.0 standard by defining a denotational semantics. It covers basic control flow and data flow, but excludes hierarchy, expansion nodes, and exception handling (see [Störrle, H., Semantics of Control-Flow in UML 2.0 Activities, in: P. Bottoni, C. Hundhausen, S. Levialdi and G. Tortora, editors, Proc. IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC) (2004), pp. 235–242, Störrle, H., Semantics of Exceptions in UML 2.0 Activities (2004), submitted to Journal of Software and Systems Modeling, May, 9th, available at www.pst.informatik.uni-muenchen.de/~stoerrle, Störrle, H., Semantics of Expansion Nodes in UML 2.0 Activities, in: I. Porres, editor, Proc. 2nd Nordic Ws. on UML, Modeling, Methods and Tools (NWUML'04), 2004] for these issues). The paper shows, where the constructs proposed in the standard are not so easily formalized, and how the formalisation may be used for formal analysis.
We describe an executable specification of the operational semantics of an asynchronous version of the π-calculus in Maude by means of conditional rewrite rules with rewrites in the conditions. We also present an executable specification of the may testing equivalence on non-recursive asynchronous π-calculus processes, using the Maude metalevel. Specifically, we describe our use of the metaSearch operation to both calculate the set of all finite traces of a non-recursive process, and to compare the trace sets of two processes according to a preorder relation that characterizes may testing in asynchronous π-calculus. Thus, in both the specification of the operational semantics and the may testing, we make heavy use of new features introduced in version 2.0 of the Maude language and system.
This paper combines two successful techniques from software engineering, aspect-oriented programming and design-by-contract, and applies them in the context of reactive systems. For the aspect language Larissa and contracts expressed with synchronous observers, we show how to apply an aspect asp to a contract C and derive a new contract C ′ , such that for any program P which fulfills C, P with asp fulfills C ′. We validate the approach on a medium-sized example. Keywords: Aspect-oriented programming, Design-by-contract, synchronous languages
We present a generic congruence closure algorithm for deciding ground formulas in the combination of the theory of equality with uninterpreted symbols and an arbitrary built-in solvable theory X. Our algorithm CC(X) is reminiscent of Shostak combination: it maintains a union-find data-structure modulo X from which maximal information about implied equalities can be directly used for congruence closure. CC(X) diverges from Shostak's approach by the use of semantic values for class representatives instead of canonized terms. Using semantic values truly reflects the actual implementation of the decision procedure for X. It also enforces to entirely rebuild the algorithm since global canonization, which is at the heart of Shostak combination, is no longer feasible with semantic values. CC(X) has been implemented in Ocaml and is at the core of Ergo, a new automated theorem prover dedicated to program verification.
In this paper we discuss and compare abstract machines for the lambda-calculus, implementing various evaluation strategies. Starting from the well-known Categorical abstract machine (CAM) and Krivine’s abstract machine (KAM), we develop two families of machines that differ in the way they treat environments. The first family is inspired by the work on closed reduction strategies, whereas the second is built in the spirit of the jumping machines based on the work done on Linear Logic Keywords: λ-calculus, environment machines, explicit substitutions, Linear Logic.
Model-centric testing (.mzT): In addition to possible input from development models, test modelling is based on user scenarios, test management information and necessary test cases from the viewpoint of the test (exceptional scenarios, error scenarios).
Specification model based testing in the development process context
This article contains three short abstracts of presentations given at the Sixth Workshop on Model-Based Testing (MBT 2010) on March 21, 2010 in Paphos, Cyprus: Theory of Model-Based Testing and How ioco Goes eco by Jan Tretmans (invited presentation), Model-Centric Testing by Florian Prester and Specification Model Based Testing in the Avionic Domain – Current Status and Future Directions by Philipp Helle and Wladimir Schamai.
Proofs Without Syntax [Hughes, D.J.D. Proofs Without Syntax. Annals of Mathematics 2006 (to appear), http://arxiv.org/abs/math/0408282 (v3). August 2004 submitted version also available: [35]] introduced polynomial-time checkable combinatorial proofs for classical propositional logic. This sequel approaches Hilbert's 24thProblem with combinatorial proofs as abstract invariants for sequent calculus proofs, analogous to homotopy groups as abstract invariants for topological spaces.The paper lifts a simple, strongly normalising cut elimination from combinatorial proofs to sequent calculus, factorising away the mechanical commutations of structural rules which litter traditional syntactic cut elimination.Sequent calculus fails to be surjective onto combinatorial proofs: the paper extracts a semantically motivated closure of sequent calculus from which there is a surjection, pointing towards an abstract combinatorial refinement of Herbrand's theorem.
We present a case study where Synchronising Graphs, a system of parallel graph transformation, are used to solve the syntactic unification problem for first order rational terms (with possibly infinite unifier). The solution we offer is efficient, that is quasi-linear, and simple: a program of 28 characters.
Message reception at stations in the DCF
Message transmission at the DCF  
Point Coordinator
The use domain of IEEE 802.11 networks has broadened to several types of application, including those that require quality of service and real-time guarantees. This trend in particular, has motivated the use of formal methods, not only to obtain a more precise knowledge of protocol properties, but also to specify and validate them. In this context, the contribution of this paper is twofold. First, we describe a formal specification of the IEEE 802.11 medium access control functions using UPPAAL, a freeware model checker tool. The described specification allowed us to verify important properties of these functions, taking into account both time and concurrency. Second, we report an experience of model checking a widely used and reasonably complex communication protocol, taking into consideration temporal requirements.
Communication protocols are often investigated using simulation. This paper presents a performance study of the distributed coordination function of 802.11 networks. Firstly, our study illustrates the different classes of Petri Nets used for modeling network protocols and their robustness in modeling based on formal methods. Next we propose a detailed 802.11b model based on Object-oriented Petri Nets that precises backoff procedure and time synchronization. Then, performance analyses are evaluated by simulation for a dense wireless network and compared with other measurements approaches. Our main goal is to propose a modular model that will enable to evaluate the impact of network performances on the performances of distributed discrete event systems.
A typical extended LAN 
Designated Bridge Election 
Bridge j is not designated for l 
The bridge predecessor LAN
The STP (Spanning Tree Protocol) which is standardized as IEEE 802.1D has been used in many bridges and switches of networks. This algorithm tries to eliminate loops in bridged networks. In this study the correctness of STP algorithm is formally verified using Extended Rebeca. In order to not to be confined to a specific case or set of cases we used a compositional verification approach. This allows us to gain generality in verifying the algorithm. The clarity and convenience in model checking by means of Extended Rebeca suggests that this language can be used for verifying more network protocols in future.
This paper is a contribution to the foundations of coinductive types and coiterative functions, in (Hyper)set-theoretical Categories, in terms of coalgebras. We consider atoms as first class citizens. First of all, we give a sharpening, in the way of cardinality, of Aczel's Special Final Coalgebra Theorem, which allows for good estimates of the cardinality of the final coalgebra. To these end, we introduce the notion of k-Y -uniform functor, which subsumes Aczel's original notion. We give also an n-ary version of it, and we show that the resulting class of functors is closed under many interesting operations used in Final Semantics.We define also canonical wellfounded versions of the final coalgebras of functors uniform on maps. This leads to a reduction of coiteration to ordinal induction, giving a possible answer to a question raised by Moss and Danner.Finally, we introduce a generalization of the notion of F-bisimulation inspired by Aczel's notion of precongruence, and we show that it allows to extend the theory of categorical bisimulations also to functors non-weakly preserving pullbacks.Examples, non-examples, and open questions are frequent in the paper.
Simplified AADL flow model 
Adding a filter
This paper presents first steps towards a formalisation of the Architecture Analysis and Design Language, mainly concentrating on a representation of its data model. For this, we contrast two approaches: one set-based (using the B modelling framework) and one in a higher-order logic (using the Isabelle proof assistant). We illustrate a transformation on a simplified part of the AADL metamodel concerning flows.
Typing rules for Lily.  
The call-by-value operational semantics of Lily.  
In a recent article [L. Birkedal, R. E. Møgelberg, and R. L. Petersen. Parametric domain-theoretic models of linear Abadi & Plotkin logic. Technical Report TR-2005-57, IT University of Copenhagen, February 2005] the first two authors and R.L. Petersen have defined a notion of parametric LAPL-structure. Such structures are parametric models of the equational theory PILLY, a polymorphic intuitionistic / linear type theory with fixed points, in which one can reason using parametricity and, for example, solve a large class of domain equations [L. Birkedal, R. E. Møgelberg, and R. L. Petersen. Parametric domain-theoretic models of linear Abadi & Plotkin logic. Technical Report TR-2005-57, IT University of Copenhagen, February 2005, L Birkedal, R. E. Møgelberg, and R. L. Petersen. Parametric domain-theoretic models of polymorphic intuitionistic / linear lambda calculus. In Proceedings of the Twenty-first Conference on the Mathematical Foundations of Programming Semantics, 2005. To appear].Based on recent work by Simpson and Rosolini [G. Rosolini and A. Simpson. Using synthetic domain theory to prove operational properties of a polymorphic programming language based on strictness. Manuscript, 2004] we construct a family of parametric LAPL-structures using synthetic domain theory and use the results of loc. cit. and results about LAPL-structures to prove operational consequences of parametricity for a strict version of the Lily programming language. In particular we can show that one can solve domain equations in the strict version of Lily up to ground contextual equivalence.
We present a methodology and a tool for suggesting repairs to web sites that violate some given requirements in the form of web rules expressed in (an extension of) a fragment of Excerpt. The methodology consists in translating these web rules into abductive logic programs with constraints and process these by means of an existing general-purpose proof procedure, called CIFF. The tool, that we call CIFFWEB, consists of CIFF as well as the translation from rules to programs and from web sites to a suitable logical format. The tool extends an existing tool for simply checking web sites against web rules.
The aim of this work is to show how to compute an extra hypothesis H to an unproved sequent Γ⊢?G, such that:•Γ,H⊢G is provable;•H is not trivial.•If Γ⊢G (which is not known a priory) then Γ,H⊢G has a much simpler proof. Due to the last item, this is not exactly the usual abductive reasoning found in literature, for the latter requires the input sequent not to be derivable.The idea is that Γ is a contextual database, containing background knowledge, G is a goal formula representing some fact or evidence that one wants to explain or prove, and H is an hypothesis that explains the evidence in the presence of the background knowledge or that facilitates the proof of G from Γ.We show how this task is related to the problem of computing non-analytic cuts. Several algorithms are provided that compute efficient proofs with non-analytic cuts via abductive reasoning.This is a joint work with Marcello D'Agostino and Dov Gabbay.
Measurements of a single spin i effect the surrounding plaquettes and vertices. A v -type qudit may be stored in the two vertices and a p -type qudit in the two plaquettes. The single spin measurements correspond to either single qudit measurements, or entangling two qudit measurements. 
The circuits to implement (a) a Fourier transform, and (b) the rotation U ( θ ). Both of these are implemented on a v -type qudit in arbitrary state | ψ . Corresponding circuits exist for p -type qudits. 
We consider topological quantum memories for a general class of abelian anyon models defined on spin lattices. These are non-universal for quantum computation when restricting to topological operations alone, such as braiding and fusion. The effects of additional non-topological operations, such as spin measurements, are studied. These are shown to allow universal quantum computation, while still utilizing topological protection. Our work gives an insight into the relation between abelian models and their non-abelian counterparts.
The approach to reasoning about structural operational semantics style specifications supported by the Abella system is discussed. This approach uses λ-tree syntax to treat object language binding and encodes binding related properties in generic judgments. Further, object language specifications are embedded directly into the reasoning framework through recursive definitions. The treatment of binding via generic judgments implicitly enforces distinctness and atomicity in the names used for bound variables. These properties must, however, be made explicit in reasoning tasks. This objective can be achieved by allowing recursive definitions to also specify generic properties of atomic predicates. The utility of these various logical features in the Abella system is demonstrated through actual reasoning tasks. Brief comparisons with a few other logic based approaches are also made.
Sets of the present-absent abstraction
Example using databases
The user
Example with no knowledge
We present a new abstraction of reactive systems interacting with databases. This abstraction is intended to be used for model-based testing. We abstract the database into two sets: present set and absent set, and present a proof of this abstraction. We present two extensions of FSM, the DBFSM and PAFSM. DBFSM are a form of FSM incorporating databases. PAFSM are an abstraction of DBFSM using present-absent sets. Depending on what type of testing is to be done, the translation is tailored to fit this purpose. We show how this translation is related to the present-absent abstraction. Finally, we illustrate the approach through a small example and show how this can be used for testing with the model-based testing tool Uppaal TRON.
We suggest that hidden algebra can provide a setting for component specification and composition that has the advantages of algebraic specification, without the disadvantages of object-oriented approaches where communication between components is mediated solely by method invocation. We propose a basic composition mechanism for hidden algebraic component specifications that is based on communication through shared subcomponents, and show that this composition mechanism on specifications extends naturally to allow models (or implementations) of the component specifications to be amalgamated into a model of the composite system.
We show how information theory can be used to give a quantitative definition of interference between variables in imperative programming languages. In this paper we focus on a particular case of this definition of interference: leakage of information from private variables to public ones in While language programs. The major result of the paper is a quantitative analysis for this language that employs a use-definition graph to calculate bounds on the leakage into each variable.
The concept of iteration theory of Bloom and Ésik summarizes all equational properties that iteration has in usual applications, e.g., in Domain Theory where to every system of recursive equations the least solution is assigned. However, this assignment in Domain Theory is also functorial. Yet, functoriality is not included in the definition of iteration theory. Pity: functorial iteration theories have a particularly simple axiomatization, and most of examples of iteration theories are functorial.The reason for excluding functoriality was the view that this property cannot be called equational. This is true from the perspective of the category Sgn of signatures as the base category: whereas iteration theories are monadic (thus, equationally presentable) over Sgn, functorial iteration theories are not. In the present paper we propose to change the perspective and work, in lieu of Sgn, in the category of sets in context (the presheaf category of finite sets and functions). We prove that Elgot theories, which is our name for functorial iteration theories, are monadic over sets in context. Shortly: from the new perspective functoriality is equational.
This paper is an overview of our results on the application of abstract interpretation concepts to various problems related to the verification of logic programs. These include the systematic design of semantics modeling various proof methods and the characterization of assertions as abstract domains. We derive an assertion based verification method and we show two instances based on different assertion languages: a decidable assertion language and CLP used as an assertion language.
Dagger compact closed categories were studied by Abramsky and Coecke (under the name “strongly compact closed categories”) as an abstract presentation of the category of Hilbert spaces and linear maps, and as a framework in which to carry out the interpretation of quantum protocols. I subsequently showed that dagger compact closed categories can also describe mixed quantum computation, where the morphisms are completely positive maps. I introduced the CPM construction as a way to pass from the pure to the mixed setting. One technical detail of the CPM(C) construction is that it does not preserve biproducts. Therefore, to obtain an interpretation of classical types such as bit=I⊕I, one must work in the free biproduct completion CPM(C)⊕. In this paper, we show that there is another view of classical types, namely as splittings of self-adjoint idempotents on quantum types. We show that all the objects of CPM(C)⊕ arise as such splittings.
Distributed Model Checking (DMC) is based on several distributed algorithms, which are often complex and error prone. In this paper, we consider one fundamental aspect of DMC design: message passing communication, the implementation of which presents hidden tradeoffs often dismissed in DMC related literature. We show that, due to such communication models, high level abstract DMC algorithms might face implicit pitfalls when implemented concretely. We illustrate our discussion with a generic distributed state space generation algorithm.
In this paper we apply the Abstract Interpretation approach [P. Cousot and R. Cousot. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. Proc. of POPL'77, 238–252, 1977; P. Cousot and R. Cousot. Systematic Design of Program Analysis Frameworks. Proc. of POPL'79, 269–282, 1979] for approximating the behavior of biological systems, modeled specifically using the Chemical Ground Form calculus [L. Cardelli. On Process Rate Semantics. Theoretical Computer Science, 391 190–215, 2008], a new stochastic calculus rich enough to model the dynamics of biochemical reactions.Our analysis computes an Interval Markov Chain (IMC) that safely approximates the Discrete-Time Markov Chain, describing the probabilistic behavior of the system, and reports both lower and upper bounds for probabilistic temporal properties. Our analysis has several advantages: (i) the method is effective (even for infinite state systems) and allows us to systematically derive an IMC from an abstract labeled transition system; (ii) using intervals for abstracting the multiplicity of reagents allows us to achieve conservative bounds for the concrete probabilities of a set of concrete experiments which differs only for initial concentrations.
We propose a typing system for the true concurrent model of event structures that guarantees the interesting behavioural properties known as conflict freeness and confusion freeness. Conflict freeness is the true concurrent version of the notion of confluence. A system is confusion free if nondeterministic choices are localised and do not depend on the scheduling of independent components. Ours is the first typing system to control behaviour in a true concurrent model. To demonstrate its applicability, we show that typed event structures give a semantics of linearly typed version of the π-calculi with internal mobility. The semantics we provide is the first event structure semantics of the π-calculus and generalises Winskel's original event structure semantics of CCS.
The CLAM Distribution Model
This paper presents the formal specification of an abstract machine or the M-calculus, a new distributed process calculus. The M-calculus can be understood as an extension of the Join calculus that realizes an original combination of the following features: programmable localities, higher-order functions and processes, process mobility, and dynamic binding. Our abstract machine covers these different features and presents a modular structure that clearly separates the sequential (functional) evaluation mechanism from the execution core, and the latter from basic marshalling, location and routing mechanisms.
We propose a benchmark to compare theorem-proving systems on their ability to express proofs of compiler correctness. In contrast to the first POPLmark, we emphasize the connection of proofs to compiler implementations, and we point out that much can be done without binders or alpha-conversion. We propose specific criteria for evaluating the utility of mechanized metatheory systems; we have constructed solutions in both Coq and Twelf metatheory, and we draw conclusions about those two systems in particular.
Quadtrees have proved popular in computer graphics and spatial databases as a way of representing regions in two dimensional space. This hierarchical data-structure is flexible enough to support non-convex and even disconnected regions, therefore it is natural to ask whether this data-structure can form the basis of an abstract domain. This paper explores this question and suggests that quadtrees offer a new approach to weakly relational domains whilst their hierarchical structure naturally lends itself to representation with boolean functions.
SIM Cards programmed in Java
Processing textual and visual descriptions
The VL-Eli toolset
Occurences of patterns in different languages
Visual languages have an important role in modeling systems, specification of software, and in specific application domains. By using visual properties like spatial placement or line connections complex structures can be presented, so that humans can understand them quickly. Visual languages can be based on domain-specific metaphors, so that domain specialists can use their conventional way of description and abstraction.For working with a visual language, a specialized graphical frontend is needed. In contrast to textual languages, general purpose editors are insufficient for visual languages, because each visual language has its particular graphical requirements. The frontend should provide methods to aid efficient drawing and restructuring of visual expressions. Often, language-specific structure editors are used as frontends for visual languages. The visual program is stored in a language-dependent data structure. The user interacts with one or more visual representations. Edit operations are directly applied to the underlying structure and after a change the graphical representation is recomputed.The implementation of visual languages requires a wide range of conceptual and technical knowledge from issues of user interface design and graphical implementation to aspects of analysis and transformation for languages in general. We present a powerful toolset that incorporates such knowledge [C. Schmidt and U. Kastens. Implementation of visual languages using pattern-based specifications. Software - Practice and Experience, 35(2):121–131, Nov. 2003]. It generates editors from high level specifications: A language is specified by identifying certain patterns in the language structure, selecting a visual representation from a set of precoined solutions, and associating the pattern to constructs of the abstract grammar. A complete visual structure editor is generated from such a specification. It represents visual programs by attributed abstract trees. Therefore, further phases of processing visual programs can be generated by state-of-the-art tools for compiler construction. Even challenging visual languages can be implemented with reasonable small effort and with rather limited technical knowledge. The approach is suitable for a large variety of visual language styles.
Infimum value of x 1 . We only display the iterates 5 to 25. At the 15th iteration, the accelerated value is used as a widening with thresholds, and the iteration stops after 18 steps.  
Static analysis by abstract interpretation aims at automatically proving properties of computer programs. To do this, an over-approximation of program semantics, defined as the least fixpoint of a system of semantic equations, must be computed. To enforce the convergence of this computation, widening operator is used but it may lead to coarse results. We propose a new method to accelerate the computation of this fixpoint by using standard techniques of numerical analysis. Our goal is to automatically and dynamically adapt the widening operator in order to maintain precision.
A cryptographic protocol is a distributed program that can be executed by several actors. Since several runs of the protocol within the same execution are allowed, models of cryptoprotocols are often infinite. Sometimes, for verification purposes, only a finite and approximated model is needed. For this, we consider the problem of computing such an approximation and we propose to simulate the required partial execution in an abstract level. More precisely, we define an abstract finite category Ga as an abstract game semantics for the SPC calculus, a dedicated calculus for security protocols. The abstract semantics is then used to build a decision procedure for secrecy correctness in security protocols.
Abramsky's Linear Chemical Abstract Machine is a term calculus which corresponds to Linear Logic, via the Curry-Howard isomorphism. We show that the typed λ-calculus is embedded into Linear Chemical Abstract Machine by Girard's embedding of Intuitionistic Logic into Linear Logic. Then we extend our result to a simple functional programming language obtained from the typed λ-calculus by adding constants from PCF. We show that the call-by-value evaluation of terms of ground types (Booleans and Natural numbers) are preserved and reflected by this translation. Finally, we discuss an operational perspective of our result. We give a sequential execution model of Linear CHAM based on Abramsky's idea of a stack of coequations and a name queue, and then we consider a concurrent multi-thread implementation of the model.
We describe an algorithm for abstract interpretation of an intermediate language in a Haskell compiler, itself also written in Haskell. It computes approximations of possible values for all variables in the program, which can be used for optimizing the object code. The analysis is done by collecting constraints on variables, which are then solved by fixpoint iteration. The set of constraints grows while solving, as possible values of unknown functions become known. The constraints are collected by decorating the abstract syntax tree with an attribute grammar based preprocessor for Haskell. An introduction to this preprocessor is also given.
In [9], we presented a theory of process structures as an equivalent, nameless presentation of the notion of “processes with names” as found in usual process calculi. It was shown there that a coherent set-like theory can be developed for nameless processes, including the counterpart of relation, function, and quotient. The present paper gives an abstract framework in which such a theory can be developed, using a pair of categories whose arrows denote possible connections among processes. In particular, the resulting universe always becomes a complete topos. The abstract treatment results in a considerable generalisation of the class of structures, some of which would shed a new light on the computational features of Linear Logic.
The interaction between Tom and GOM
This paper presents GOM, a language for describing abstract syntax trees and generating a Java implementation for those trees. GOM includes features allowing the user to specify and modify the interface of the data structure. These features provide in particular the capability to maintain the internal representation of data in canonical form with respect to a rewrite system. This explicitly guarantees that the client program only manipulates normal forms for this rewrite system, a feature which is only implicitly used in many implementations.
We derive an abstract machine from the Curry-Howard correspondence with a sequent calculus presentation of Intuitionistic Propositional Linear Logic. The states of the register based abstract machine comprise a low-level code block, a register bank and a dump holding suspended procedure activations. Transformation of natural deduction proofs into our sequent calculus yields a type-preserving compilation function from the Linear Lambda Calculus to the abstract machine. We prove correctness of the abstract machine with respect to the standard call-by-value evaluation semantics of the Linear Lambda Calculus.
Top-cited authors
Jose Meseguer
  • University of Illinois, Urbana-Champaign
Tom Mens
  • Université de Mons
Pieter Van Gorp
  • Eindhoven University of Technology
John Power
  • Macquarie University
Eelco Visser
  • Delft University of Technology