We present an overview of the Java PathExplorer runtime verification tool, in short referred to as JPaX. JPaX can monitor the execution of a Java program and check that it conforms with a set of user provided properties formulated in temporal logic. JPaX can in addition analyze the program for concurrency errors such as deadlocks and data races. The concurrency analysis requires no user provided specification. The tool facilitates automated instrumentation of a program’s bytecode, which when executed will emit an event stream, the execution trace, to an observer. The observer dispatches the incoming event stream to a set of observer processes, each performing a specialized analysis, such as the temporal logic verification, the deadlock analysis and the data race analysis. Temporal logic specifications can be formulated by the user in the Maude rewriting logic, where Maude is a high-speed rewriting system for equational logic, but here extended with executable temporal logic. The Maude rewriting engine is then activated as an event driven monitoring process. Alternatively, temporal specifications can be translated into efficient automata, which check the event stream. JPaX can be used during program testing to gain increased information about program executions, and can potentially furthermore be applied during operation to survey safety critical systems.

In this paper, we show that one can "deep-embed" the Java bytecode language, a fairly complicated language with a rich semantics, into the first order logic of ACL2 by modeling a realistic JVM. We show that with proper support from a semi-automatic theorem prover in that logic, one can reason about the correctness of Java programs. This reasoning can be done in a direct and intuitive way without incurring the extra burden that has often been associated with hand proofs, or proofs that make use of less automated proof assistance. We present proofs for two simple Java programs as a showcase.

This document explains the design and use of a coherence checker tool and of a coherence completion tool. The coherence checker tool checks whether a rewrite logic specification is coherent, and the coherence completion tool tries to complete a rewrite logic specification in order to make it coherent. These tools can be used to prove the coherence property or to coherence complete order-sorted rewrite specifications in Maude [7, 5, 2]. The tools have been written entirely in Maude and are in fact executable specifications in rewriting logic [14] of the formal inference system that they implement. The fact that rewriting logic is reflective [8, 1], and that Maude efficiently supports reflective rewriting logic computations [3, 2] is systematically exploited in the design of the tools.

This article discusses how artificial intelligence (AI) planning techniques can be used to enable automatic composition of Web Services. Particulary, the paper discusses how standard Web Service descriptions can be annotated and converted into proper formats like PDDL to enable reasoning with modern AI planning tools. 1

We investigate using algebraic methods and the support tool Maude to formally specify and reason about the well known iterator design pattern. We begin by specifying instances of the iterator pattern which can be described equationally using Maude. We then develop an abstract specification which we argue captures the essence of the iterator pattern. We conclude by specifying a possible refinement for iterator instances, a so called filter refinement, and by formally proving that this refinement is correct with respect to our abstract specification.

In an open system, multi-agent computations must compete for resources required for satisfying their goals. We describe CyberOrgs, a hierarchical model for acquisition and control of resources for multi-agent systems in a market of resources. Programming abstractions and constructs are introduced for implementing systems of CyberOrgs. A prototype implementation of the model as an Actor program is described, and scheduling approaches for an efficient implementation are discussed.

We view models of rewrite theories enriched with observations coalgebraically. This allows us on the one hand to use “off the shelf ” logics for coalgebras to specify and, on the other hand, to verify properties of rewriting programs and to obtain results about the expressive power of such languages. 1