Search

In a recent paper we introduced a new framework for the study of call by need computations. Using elementary tree automata techniques and ground tree transducers we obtained simple decidability proofs for a hierarchy of classes of rewrite systems that are much larger than earlier classes defined using the complicated sequentiality concept. In this paper we study the modularity of membership in the new hierarchy. Surprisingly, it turns out that none of the classes in the hierarchy is preserved under signature extension. By imposing various conditions we recover the preservation under signature extension. By imposing some more conditions we are able to strengthen the signature extension results to modularity for disjoint and constructor-sharing combinations. [ABSTRACT FROM AUTHOR]

Two-way alternating automata on trees were introduced by Vardi [Va98]. Here we consider alternating two-way automata on graphs and show the decidability of the following problem: "does a given automaton with the Büchi condition accept any finite graph?" Using this result we demonstrate the decidability of the finite model problem for a certain fragment of the modal µ-calculus with backward modalities. [ABSTRACT FROM AUTHOR]

We study the expressiveness of the join calculus by comparison with (generalised, coloured) Petri nets and using tools from type theory. More precisely, we consider four classes of nets of increasing expressiveness, ∏i, introduce a hierarchy of type systems of decreasing strictness, Δi, i = 0,..., 3, and we prove that a join process is typeable according to Δi if and only if it is (strictly equivalent to) a net of class ∏i. In the details, ∏0 and ∏1 contain, resp., usual place/transition and coloured Petri nets, while ∏2 and ∏3 propose two natural notions of high-level net accounting for dynamic reconfiguration and process creation and called reconfigurable and dynamic Petri nets, respectively. [ABSTRACT FROM AUTHOR]

This paper discusses decidability and existence of principal types in type assignment systems for λ-terms in which types are considered modulo an equivalence relation induced by a set of type equations. There are two interesting ways of defining such equivalence, an initial and a final one. A suitable transformation will allow to treat both in an uniform way. [ABSTRACT FROM AUTHOR]

We present the architecture of Marrella, a tool designed for simulation and verification of distributed systems. The input of the tool is an event driven language whereas the underlying model is event structures. It gives the possibilities of generating one, some or all the executions of any distributed program. We have tested the tool for the verification of an embedded system. The corresponding results are reported here as well as those obtained with equivalent tools applied to the same case study. These experimental results show then the efficiency of Marrella. [ABSTRACT FROM AUTHOR]

We propose an axiomatic semantics for the synchronous language Gentzen, which is an instantiation of the paradigm Timed Concurrent Constraint Programming. We view Gentzen as a prototype of the class of state-oriented synchronous languages, since it offers the basic constructs that are shared by the languages in the class. Since synchronous concurrency cannot be simulated by arbitrary interleaving, we cannot exploit "head normal forms", on which axiomatic theories for asynchronous process calculi are based. [ABSTRACT FROM AUTHOR]

In the past decade there has been a variety of results showing decidability of bisimulation equivalence between infinite state systems. The initial result, due to Baeten, Bergstra and Klop [1], proved decidability for normed BPA processes, described using irredundant context-free grammars. This was extended to all BPA processes and then to pushdown automata [5,16,14]. Decidability of bisimilarity was also shown for Basic Parallel (BP) processes, a restricted subset of Petri nets, [4]. For full Petri nets Jančar proved that bisimulation equivalence is undecidable [11]. [ABSTRACT FROM AUTHOR]

Higher-order abstract syntax is a natural way to formalize programming languages with binders, like the π-calculus, because α-conversion, instantiations and capture avoidance are delegated to the meta-level of the provers, making tedious substitutions superfluous. However, such formalizations usually lack structural induction, which makes syntax-analysis impossible. Moreover, when applied in logical frameworks with object-logics, like Isabelle/HOL or standard extensions of Coq, exotic terms can be defined, for which important syntactic properties become invalid. The paper presents a formalization of the π-calculus in Isabelle/HOL, using well-formedness predicates which both eliminate exotic terms and yield structural induction. These induction-principles are then used to derive the Theory of Contexts fully within the mechanization. [ABSTRACT FROM AUTHOR]

Using the theorem prover Isabelle/HOL we have formalized and proved correct an executable bytecode verifier in the style of Kildall's algorithm for a significant subset of the Java Virtual Machine. First an abstract framework for proving correctness of data flow based type inference algorithms for assembly languages is formalized. It is shown that under certain conditions Kildall's algorithm yields a correct bytecode verifier. Then the framework is instantiated with a model of the JVM. [ABSTRACT FROM AUTHOR]

Hierarchical Message Sequence Charts are a well-established formalism to specify telecommunication protocols. In this model, numerous undecidability results were obtained recently through algebraic approaches or relationships to Mazurkiewicz trace theory. We show how to check whether a rational language of MSCs requires only channels of finite capacity. In that case, we also provide an upper bound for the size of the channels. This enables us to prove our main result: one can decide whether the iteration of a given regular language of MSCs is regular if, and only if, the Star Problem in trace monoids (over some restricted independence alphabets) is decidable too. [ABSTRACT FROM AUTHOR]

Among the branching-time temporal logics used for the specification and verification of systems, CTL+, FCTL and ECTL+ are the most notable logics for which the precise computational complexity of model checking is not known. We answer this longstanding open problem and show that model checking these (and some related) logics is ΔStackpstack2-complete. [ABSTRACT FROM AUTHOR]

Simulations between processes can be understood in terms of coalgebra homomorphisms, with homomorphisms to the final coalgebra exactly identifying bisimilar processes. The elements of the final coalgebra are thus natural representatives of bisimilarity classes, and a denotational semantics of processes can be developed in a final-coalgebra- enriched category where arrows are processes, canonically represented. In the present paper, we describe a general framework for building final- coalgebra-enriched categories. Every such category is constructed from a multivariant functor representing a notion of process, much like Moggi's categories of computations arising from monads as notions of computation. The "notion of process" functors are intended to capture different flavors of processes as dynamically extended computations. These functors may involve a computational (co)monad, so that a process category in many cases contains an associated computational category as a retract. We further discuss categories of resumptions and of hyperfunctions, which are the main examples of process categories. Very informally, the resumptions can be understood as computations extended in time, whereas hypercomputations are extended in space. [ABSTRACT FROM AUTHOR]

Graph Transformations provide a uniform and precise framework for the specification of access control policies allowing the detailed comparison of different policy models and the precise description of the evolution of a policy. Furthermore, the framework is used for an accurate analysis of the interaction between policies and of the behavior of their integration with respect to the problem of conflicting rules. The integration of policies is illustrated using the Discretionary Access Control and the Lattice Based Access Control policies. [ABSTRACT FROM AUTHOR]

Different types of nondeterministic automata on infinite words differ in their succinctness and in the complexity for their nonemptiness problem. A simple translation of a parity automaton to an equivalent Büchi automaton is quadratic: a parity automaton with n states, m transitions, and index k may result in a Büchi automaton of size O((n + m)k). The best known algorithm for the nonemptiness problem of parity automata goes through Büchi automata, leading to a complexity of O((n + m)k). In this paper we show that while the translation of parity automata to Büchi automata cannot be improved, the special structure of the acceptance condition of parity automata can be used in order to solve the nonemptiness problem directly, with a dynamic graph algorithm of complexity O((n + m) log k). [ABSTRACT FROM AUTHOR]

We use abstract interpretation to define a uniform formalism for presenting and comparing class analyses for object-oriented languages. We consider three domains for class analysis derived from three techniques present in the literature, viz., rapid type analysis, a simple dataflow analysis and constraint-based 0-CFA analysis. We obtain three static analyses which are provably correct and whose abstract operations are provably optimal. Moreover, we prove that our formalisation of the 0-CFA analysis is more precise than that of the dataflow analysis. [ABSTRACT FROM AUTHOR]

We propose an axiomatization of fixpoint operators in typed call-by-value programming languages, and give its justifications in two ways. First, it is shown to be sound and complete for the notion of uniform T-fixpoint operators of Simpson and Plotkin. Second, the axioms precisely account for Filinski's fixpoint operator derived from an iterator (infinite loop constructor) in the presence of first-class controls, provided that we define the uniformity principle on such an iterator via a notion of effect-freeness (centrality). We also investigate how these two results are related in terms of the underlying categorical models. [ABSTRACT FROM AUTHOR]

We identify a set of programming constructs ensuring that a programming language based on graph transformation is computationally complete. These constructs are (1) nondeterministic application of a set of graph transformation rules, (2) sequential composition and (3) iteration. This language is minimal in that omitting either sequential composition or iteration results in a computationally incomplete language. By computational completeness we refer to the ability to compute every computable partial function on labelled graphs. Our completeness proof is based on graph transformation programs which encode arbitrary graphs as strings, simulate Turing machines on these strings, and decode the resulting strings back into graphs. [ABSTRACT FROM AUTHOR]

We present a new formulation for tree-tuple synchronized languages, much simpler than the existing one. This new formulation allows us to prove stronger structural results. As a consequence, synchronized languages give rise to new applications: — to rewriting: given tree languages L1 (synchronized), L2 (regular), Rel(L1) ⊆ L2 is decidable for several rewrite-like relations Rel. — to concurrency: we prove decidability of the logic EF for a process calculus allowing some bounded form of communication. Consequently, the absence of deadlocks is decidable. [ABSTRACT FROM AUTHOR]

The rewriting calculus, or Rho Calculus (ρCal), is a simple calculus that uniformly integrates abstraction on patterns and non- determinism. Therefore, it fully integrates rewriting and λ-calculus. The original presentation of the calculus was untyped. In this paper we present a uniform way to decorate the terms of the calculus with types. This gives raise to a new presentation à la Church, together with nine (8+1) type systems which can be placed in a ρ-cube that extends the λ-cube of Barendregt. Due to the matching capabilities of the calculus, the type systems use only one abstraction mechanism and therefore gives an original answer to the identification of the standard "λ" and "∏" abstractors. As a consequence, this brings matching and rewriting as the first class concepts of the Rho-versions of the Logical Framework (LF) of Harper-Honsell-Plotkin, and of the Calculus of Constructions (CC) of Coquand-Huet. [ABSTRACT FROM AUTHOR]

We settle the complexity bounds of the model checking problem for the replication-free ambient calculus with public names against the ambient logic without parallel adjunct. We show that the problem is PSPACE-complete. For the complexity upper-bound, we devise a new representation of processes that remains of polynomial size during process execution; this allows us to keep the model checking procedure in polynomial space. Moreover, we prove PSPACE-hardness of the problem for several quite simple fragments of the calculus and the logic; this suggests that there are no interesting fragments with polynomial-time model checking algorithms. [ABSTRACT FROM AUTHOR]

The shared dataspace metaphor is historically the most prominent representative of the family of coordination models. According to this approach, concurrent processes interact via the production, consumption, and test for presence/absence of data in a common repository. Recently, the problem of the accumulation of outdated and unwanted information in the shared repository has been addressed and it has been solved by introducing non-permanent data, obtained by associating an expiration time to data. In this paper we investigate the impact of the adoption of different notions of non-permanent data on the expressiveness of a Linda based process calculus. [ABSTRACT FROM AUTHOR]

Garbage collection relieves the programmer of the burden of managing dynamically allocated memory, by providing an automatic way to reclaim unneeded storage. This eliminates or lessens program errors that arise from attempts to access disposed memory, and generally leads to simpler programs. One might therefore expect that reasoning about programs in garbage collected languages would be much easier than in languages where the programmer has more explicit control over memory. But existing program logics are based on a low level view of storage that is sensitive to the presence or absence of unreachable cells, and Reynolds has pointed out that the Hoare triples derivable in these logics are even incompatible with garbage collection. We present a semantics of program logic assertions based on a view of the heap as finite, but extensible; this is for a logical language with primitives for dereferencing pointer expressions. The essential property of the semantics is that all propositions are invariant under operations of adding or removing garbage cells; in short, they are garbage insensitive. We use the assertion language to formulate notions of partial and total correctness for a small programming language, and provide logical characterizations of two natural notions of observational equivalence between programs. [ABSTRACT FROM AUTHOR]

Observability and reachability are important concepts in formal software development. While observability concepts allow to specify the required observable behavior of a program or system, reachability concepts are used to describe the underlying data in terms of data type constructors. In this paper we show that there is a duality between observability and reachability, both from a methodological and from a formal point of view. In particular, we establish a correspondence between observer operations and data type constructors, observational algebras and constructor-based algebras, and observational and inductive properties of specifications. Our study is based on the observational logic institution [7] and on a novel treatment of reachability which introduces the institution of constructor-based logic. The duality between both concepts is formalised in a category-theoretic setting. [ABSTRACT FROM AUTHOR]

We propose a theoretical foundation for proof reuse, based on the novel idea of a computational interpretation of type isomorphisms. [ABSTRACT FROM AUTHOR]

This paper studies the equational theory of various exotic semirings presented in the literature. Exotic semirings are semirings whose underlying carrier set is some subset of the set of real numbers equipped with binary operations of minimum or maximum as sum, and addition as product. Two prime examples of such structures are the (max, +) semiring and the tropical semiring. It is shown that none of the exotic semirings commonly considered in the literature has a finite basis for its equations, and that similar results hold for the commutative idempotent weak semirings that underlie them. For each of these commutative idempotent weak semirings, the paper offers characterizations of the equations that hold in them, explicit descriptions of the free algebras in the varieties they generate, and relative axiomatization results. [ABSTRACT FROM AUTHOR]

We develop a typed process calculus for security protocols in which types convey secrecy properties. We focus on asymmetric communication primitives, especially on public-key encryption. These present special difficulties, partly because they rely on related capabilities (e.g., "public" and "private" keys) with different levels of secrecy and scopes. [ABSTRACT FROM AUTHOR]

Moggi proposed a monadic account of computational effects. He also presented the computational λ-calculus, λc, a core call-by-value functional programming language for effects; the effects are obtained by adding appropriate operations. The question arises as to whether one can give a corresponding treatment of operational semantics. We do this in the case of algebraic effects where the operations are given by a single-sorted algebraic signature, and their semantics is supported by the monad, in a certain sense. We consider call-by-value PCF with— and without—recursion, an extension of λc with arithmetic. We prove general adequacy theorems, and illustrate these with two examples: non-determinism and probabilistic nondeterminism. [ABSTRACT FROM AUTHOR]

In this paper we address the problem of solving recursive domain equations using uncountable limits of domains. These arise for instance, when dealing with the ω1-continuous function-space constructor and are used in the (generative) denotational semantics of programming languages which feature non-deterministic fair constructs implemented with unbounded choice. It is well known that such features cannot be modeled using just Scott-continuous functions; they can be modeled conveniently, instead, using functions which satisfy the weaker continuity property of ω1-continuity. Surprisingly, the category of cpo's and ω1-continuous embeddings is not ω0-cocomplete. Hence the standard technique of Adámek and Koubek for solving reflexive domain equations involving these constructs fails. This phenomenon was not noticed before in the literature. We discuss two alternative methods that can be used to solve the required domain equations. The first one is an application of the method of Adámek and Koubek to a different category. The second one, instead, is a genuine extension of their method and amounts to considering cones instead of limits. We put both methods on solid categorical grounds and discuss some applications. Finally we utilise the second method in order to give a model for the untyped λ-calculus whose theory is precisely the λβη theory. Thus we show that ω1-lambda models are complete for the λβη-calculus. [ABSTRACT FROM AUTHOR]