89,878 research outputs found
On coalgebras with internal moves
In the first part of the paper we recall the coalgebraic approach to handling
the so-called invisible transitions that appear in different state-based
systems semantics. We claim that these transitions are always part of the unit
of a certain monad. Hence, coalgebras with internal moves are exactly
coalgebras over a monadic type. The rest of the paper is devoted to supporting
our claim by studying two important behavioural equivalences for state-based
systems with internal moves, namely: weak bisimulation and trace semantics.
We continue our research on weak bisimulations for coalgebras over order
enriched monads. The key notions used in this paper and proposed by us in our
previous work are the notions of an order saturation monad and a saturator. A
saturator operator can be intuitively understood as a reflexive, transitive
closure operator. There are two approaches towards defining saturators for
coalgebras with internal moves. Here, we give necessary conditions for them to
yield the same notion of weak bisimulation.
Finally, we propose a definition of trace semantics for coalgebras with
silent moves via a uniform fixed point operator. We compare strong and weak
bisimilation together with trace semantics for coalgebras with internal steps.Comment: Article: 23 pages, Appendix: 3 page
Towards a Maude tool for model checking temporal graph properties
We present our prototypical tool for the verification of graph transformation systems. The major novelty of our tool is that it provides a model checker for temporal graph properties based on counterpart semantics for quantified m-calculi. Our tool can be considered as an instantiation of our approach to counterpart semantics which allows for a neat handling of creation, deletion and merging in systems
with dynamic structure. Our implementation is based on the object-based machinery of Maude, which provides the basics to deal with attributed graphs. Graph transformation
systems are specified with term rewrite rules. The model checker evaluates logical formulae of second-order modal m-calculus in the automatically generated CounterpartModel (a sort of unfolded graph transition system) of the graph transformation system under study. The result of evaluating a formula is a set of assignments for each state, associating node variables to actual nodes
Towards Practical Graph-Based Verification for an Object-Oriented Concurrency Model
To harness the power of multi-core and distributed platforms, and to make the
development of concurrent software more accessible to software engineers,
different object-oriented concurrency models such as SCOOP have been proposed.
Despite the practical importance of analysing SCOOP programs, there are
currently no general verification approaches that operate directly on program
code without additional annotations. One reason for this is the multitude of
partially conflicting semantic formalisations for SCOOP (either in theory or
by-implementation). Here, we propose a simple graph transformation system (GTS)
based run-time semantics for SCOOP that grasps the most common features of all
known semantics of the language. This run-time model is implemented in the
state-of-the-art GTS tool GROOVE, which allows us to simulate, analyse, and
verify a subset of SCOOP programs with respect to deadlocks and other
behavioural properties. Besides proposing the first approach to verify SCOOP
programs by automatic translation to GTS, we also highlight our experiences of
applying GTS (and especially GROOVE) for specifying semantics in the form of a
run-time model, which should be transferable to GTS models for other concurrent
languages and libraries.Comment: In Proceedings GaM 2015, arXiv:1504.0244
Towards a directed homotopy type theory
In this paper, we present a directed homotopy type theory for reasoning
synthetically about (higher) categories, directed homotopy theory, and its
applications to concurrency. We specify a new `homomorphism' type former for
Martin-L\"of type theory which is roughly analogous to the identity type former
originally introduced by Martin-L\"of. The homomorphism type former is meant to
capture the notions of morphism (from the theory of categories) and directed
path (from directed homotopy theory) just as the identity type former is known
to capture the notions of isomorphism (from the theory of groupoids) and path
(from homotopy theory). Our main result is an interpretation of these
homomorphism types into Cat, the category of small categories. There, the
interpretation of each homomorphism type hom(a,b) is indeed the set of
morphisms between the objects a and b of a category C. We end the paper with an
analysis of the interpretation in Cat with which we argue that our homomorphism
types are indeed the directed version of Martin-L\"of's identity types
A Formal, Resource Consumption-Preserving Translation of Actors to Haskell
We present a formal translation of an actor-based language with cooperative
scheduling to the functional language Haskell. The translation is proven
correct with respect to a formal semantics of the source language and a
high-level operational semantics of the target, i.e. a subset of Haskell. The
main correctness theorem is expressed in terms of a simulation relation between
the operational semantics of actor programs and their translation. This allows
us to then prove that the resource consumption is preserved over this
translation, as we establish an equivalence of the cost of the original and
Haskell-translated execution traces.Comment: Pre-proceedings paper presented at the 26th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2016), Edinburgh,
Scotland UK, 6-8 September 2016 (arXiv:1608.02534
Towards a homotopy theory of process algebra
This paper proves that labelled flows are expressive enough to contain all
process algebras which are a standard model for concurrency. More precisely, we
construct the space of execution paths and of higher dimensional homotopies
between them for every process name of every process algebra with any
synchronization algebra using a notion of labelled flow. This interpretation of
process algebra satisfies the paradigm of higher dimensional automata (HDA):
one non-degenerate full -dimensional cube (no more no less) in the
underlying space of the time flow corresponding to the concurrent execution of
actions. This result will enable us in future papers to develop a
homotopical approach of process algebras. Indeed, several homological
constructions related to the causal structure of time flow are possible only in
the framework of flows.Comment: 33 pages ; LaTeX2e ; 1 eps figure ; package semantics included ; v2
HDA paradigm clearly stated and simplification in a homotopical argument ; v3
"bug" fixed in notion of non-twisted shell + several redactional improvements
; v4 minor correction : the set of labels must not be ordered ; published at
http://intlpress.com/HHA/v10/n1/a16
Modal logics for reasoning about object-based component composition
Component-oriented development of software supports the adaptability and maintainability of large systems, in particular if requirements change over time and parts of a system have to be modified or replaced. The software architecture in such systems can be described by components
and their composition. In order to describe larger architectures, the composition concept becomes crucial. We will present a formal framework for component composition for object-based software development. The deployment of modal logics for defining components and component composition will allow us to reason about and prove properties of components and compositions
- âŠ