A clausal resolution for extended computation tree logic ECTL

A temporal clausal resolution method was originally developed for linear time temporal logic and further extended to the branching-time framework of Computation Tree Logic (CTL). In this paper, following our general idea to expand the applicability of this efficient method to more expressive formalisms useful in a variety of applications in computer science and AI requiring branching time logics, we define a clausal resolution technique for Extended Computation Tree Logic (ECTL). The branching-time temporal logic ECTL is strictly more expressive than CTL, in allowing fairness operators. The key elements of the resolution method for ECTL, namely the clausal normal form, the concepts of step resolution and a temporal resolution, are introduced and justified with respect to this new framework. Although in developing these components we incorporate many of the techniques defined for CTL, we need novel mechanisms in order to capture fairness together with the limit closure property of the underlying tree models. We accompany our presentation of the relevant techniques by examples of the application of the temporal resolution method. Finally, we provide a correctness argument and consider future work discussing an extension of the method yet further, to the logic CTL*, the most powerful logic of this class

A clausal resolution method for branching-time logic ECTL+

We expand the applicability of the clausal resolution technique to the branching-time temporal logic ECTL_. ECTL_ is strictly more expressive than the basic computation tree logic CTL and its extension, ECTL, as it allows Boolean combinations of fairness and single temporal operators. We show that any ECTL_ formula can be translated to a normal form the structure of which was initially defined for CTL and then applied to ECTL. This enables us to apply to ECTL_ a resolution technique defined over the set of clauses. Our correctness argument also bridges the gap in the correctness proof for ECTL: we show that the transformation procedure for ECTL preserves unsatisfiability

Search strategies for resolution in CTL-type logics: extension and complexity

A clausal resolution approach originally developed for the branching logic CTL has recently been extended to the logics ECTL and ECTL+. In the application of the resolution rules searching for a loop is essential. In this paper we define a Depth-First technique to complement the existing Breadth-First Search and provide the complexity analysis of the developed methods. Additionally, it contains a correction in our previous presentation of loops

Specification and verification of reconfiguration protocols in grid component systems

In this work we present an approach for the formal specification and verification of the reconfiguration protocols in Grid component systems. We consider Fractal, a modular and extensible component model. As a specification tool we invoke a specific temporal language, separated clausal normal form, which has been shown to be capable of expressing any ECTL+ expression thus, we are able to express the complex fairness properties of a component system. The structure of the normal enables us to directly apply the deductive verification technique, temporal resolution defined in the framework of branching-time temporal logic

On the Expressive Power of the Normal Form for Branching-Time Temporal logics

With the emerging applications that involve complex distributed systems branching-time specifications are specifically important as they reflect dynamic and non-deterministic nature of such applications. We describe the expressive power of a simple yet powerful branching-time specification framework – branching-time normal form, which has been developed as part of clausal resolution for branching-time temporal logics. We show the encoding of B¨uchi Tree Automata in the language of the normal form, thus representing, syntactically, tree automata in a high-level way. Thus we can treat BNF as a normal form for the latter. These results enable us (1) to translate given problem specifications into the normal form and apply as a verification method a deductive reasoning technique – the clausal temporal resolution; (2) to apply one of the core components of the resolution method - the loop searching to extract, syntactically, hidden invariants in a wide range of complex temporal specifications

Dynamic reconfiguration of GCM components

We detail in this report past research and current/future developments in formal specification of Grid component systems by temporal logic and consequent resolution technique, for an automated dynamic reconfiguration of components. It is analysed the specification procedure of GCM (Grid Component Model) components and infrastructure in respect to their state behaviour, and the verification process in a dynamic and reconfigurable distributed system. Furthermore it is demonstrated how an automata based method is used to achieve the specification, as well as how the enrichment of the temporal specification language of Computation Tree Logic CTL with the ability to capture norms, allows to formally define the concept of reconfiguration

Discovering of System’s Invariants by Temporal Reasoning

We present a technique to handle invariants in the branching-time setting, for the specifications written in the formalism called Branching Normal Form (BNF). The language of BNF was previously used as part of the deductive clausal resolution method for a variety of branching-time logics. We show how this framework can tackle useful periodic properties, or invariants. We emphasise the potential power of this approach to the process of reconfiguration of an adaptive system where preserving invariant properties is essential

Integrating formal reasoning into component-based approach to reconfigurable distributed systems

Distributed computing is becoming ubiquitous in recent years in many areas, especially the scientific and industrial ones, where the processing power - even that of supercomputers - never seems to be enough. Grid systems were born out of necessity, and had to grow quickly to meet requirements which evolved over time, becoming today’s complex systems. Even the simplest distributed system nowadays is expected to have some basic functionalities, such as resources and execution management, security and optimization features, data control, etc. The complexity of Grid applications is also accentuated by their distributed nature, making them some of the most elaborate systems to date. It is often too easy that these intricate systems happen to fall in some kind of failure, it being a software bug, or plain simple human error; and if such a failure occurs, it is not always the case that the system can recover from it, possibly meaning hours of wasted computational power. In this thesis, some of the problems which are at the core of the development and mainte- nance of Grid software applications are addressed by introducing novel and solid approaches to their solution. The difficulty of Grid systems to deal with unforeseen and unexpected cir- cumstances resulting from dynamic reconfiguration can be identified. Such problems are often related to the fact that Grid applications are large, distributed and prone to resource failures. This research has produced a methodology for the solution of this problem by analysing the structure of distributed systems and their reliance on the environment which they sit upon, often overlooked when dealing with these types of scenarios. It is concluded that the way that Grid applications interact with the infrastructure is not sufficiently addressed and a novel approach is developed in which formal verification methods are integrated with distributed applications development and deployment in a way that includes the environment. This approach allows for reconfiguration scenarios in distributed applications to proceed in a safe and controlled way, as demonstrated by the development of a prototype application

Temporal specification and deductive verification of a distributed component model and its environment

In this paper we investigate the formalisation of distributed and long-running stateful systems using our normative temporal specification framework. We analyse aspects of a component-oriented Grid system, and the benefits of having a logic-based tool to perform automated and safe dynamic reconfiguration of its components. We describe which parts of this Grid system are involved in the reconfiguration process and detail the translation procedure into a state-based formal specification. Subsequently, we apply deductive verification to test whether dynamic reconfiguration can be performed. Finally, we analyse the procedure required to update our model for reconfiguration and justify the validity and the advantages of our methodology