Action Language: a specification language for model checking reactive systems

2002 ◽  
Author(s):  
T. Bultan
Keyword(s):  
Model Checking ◽  
Reactive Systems ◽  
Specification Language ◽  
Action Language

scholarly journals On Computational Tractability for Rational Verification

2019 ◽  
Author(s):  
Julian Gutierrez ◽  
Muhammad Najib ◽  
Giuseppe Perelli ◽  
Michael Wooldridge
Keyword(s):  
Model Checking ◽  
Temporal Logic ◽  
Multiagent Systems ◽  
Polynomial Time ◽  
Multiagent System ◽  
Reactive Systems ◽  
State System ◽  
Polynomial Space ◽  
Game Theoretic ◽  
Mean Payoff

Rational verification involves checking which temporal logic properties hold of a concurrent and multiagent system, under the assumption that agents in the system choose strategies in game theoretic equilibrium. Rational verification can be understood as a counterpart of model checking for multiagent systems, but while model checking can be done in polynomial time for some temporal logic specification languages such as CTL, and polynomial space with LTL specifications, rational verification is much more intractable: it is 2EXPTIME-complete with LTL specifications, even when using explicit-state system representations.  In this paper we show that the complexity of rational verification can be greatly reduced by restricting specifications to GR(1), a fragment of LTL that can represent most response properties of reactive systems. We also provide improved complexity results for rational verification when considering players' goals given by mean-payoff utility functions -- arguably the most widely used quantitative objective for agents in concurrent and multiagent systems. In particular, we show that for a number of relevant settings, rational verification can be done in polynomial space or even in polynomial time.

scholarly journals Formal Requirements Capturing using VRS system

10.29007/q6mc ◽  
2018 ◽  
Author(s):  
Alexander Letichevsky ◽  
Alexander Kolchin ◽  
Oleksandr Letychevskyy jr. ◽  
Stepan Potiyenko ◽  
Vlad Volkov ◽  
...  
Keyword(s):  
Model Checking ◽  
Software Development ◽  
Theorem Proving ◽  
Specification Language ◽  
System Support ◽  
Development Projects ◽  
Short Overview ◽  
Formal Requirements

We give a short overview of main functionalities and specification language of the VRS system. That environment was succesfully used for formalization and verification of ~30 software development projects implemented in Motorola. The system support both model checking and theorem proving techniques enhanced with invariants generation.

Generalised Test Tables: A Practical Specification Language for Reactive Systems

2017 ◽  
pp. 129-144 ◽  
Author(s):  
Bernhard Beckert ◽  
Suhyun Cha ◽  
Mattias Ulbrich ◽  
Birgit Vogel-Heuser ◽  
Alexander Weigl
Keyword(s):  
Reactive Systems ◽  
Specification Language

scholarly journals Automatic verification of timed concurrent constraint programs

2006 ◽  
Vol 6 (3) ◽  
pp. 265-300 ◽  
Author(s):  
MORENO FALASCHI ◽  
ALICIA VILLANUEVA
Keyword(s):  
Model Checking ◽  
Infinite Number ◽  
Reactive Systems ◽  
Finite Model ◽  
Computation Model ◽  
Huge Number ◽  
Finite State ◽  
Infinite State Systems ◽  
Infinite State ◽  
Concurrent Constraint Programming

The language Timed Concurrent Constraint (tccp) is the extension over time of the Concurrent Constraint Programming (cc) paradigm that allows us to specify concurrent systems where timing is critical, for example reactive systems. Systems which may have an infinite number of states can be specified in tccp. Model checking is a technique which is able to verify finite-state systems with a huge number of states in an automatic way. In the last years several studies have investigated how to extend model checking techniques to systems with an infinite number of states. In this paper we propose an approach which exploits the computation model of tccp. Constraint based computations allow us to define a methodology for applying a model checking algorithm to (a class of) infinite-state systems. We extend the classical algorithm of model checking for LTL to a specific logic defined for the verification of tccp and to the tccp Structure which we define in this work for modeling the program behavior. We define a restriction on the time in order to get a finite model and then we develop some illustrative examples. To the best of our knowledge this is the first approach that defines a model checking methodology for tccp.

scholarly journals Spectra: a specification language for reactive systems

2021 ◽  
Author(s):  
Shahar Maoz ◽  
Jan Oliver Ringert
Keyword(s):  
Reactive Systems ◽  
Specification Language ◽  
Lessons Learned ◽  
Science Students ◽  
Future Studies ◽  
Reactive Synthesis ◽  
Quality Specifications ◽  
Software Engineers ◽  
Tool Set ◽  
Potential Use

AbstractWe introduce Spectra, a new specification language for reactive systems, specifically tailored for the context of reactive synthesis. The meaning of Spectra is defined by a translation to a kernel language. Spectra comes with the Spectra Tools, a set of analyses, including a synthesizer to obtain a correct-by-construction implementation, several means for executing the resulting controller, and additional analyses aimed at helping engineers write higher-quality specifications. We present the language in detail and give an overview of its tool set. Together with the language and its tool set, we present four collections of many, non-trivial, large specifications, written by undergraduate computer science students for the development of autonomous Lego robots and additional example reactive systems. The collected specifications can serve as benchmarks for future studies on reactive synthesis. We present the specifications, with observations and lessons learned about the potential use of reactive synthesis by software engineers.

scholarly journals On the Satisfiability and Model Checking for one Parameterized Extension of Linear-time Temporal Logic

2021 ◽  
Vol 28 (4) ◽  
pp. 356-371
Author(s):  
Anton Romanovich Gnatenko ◽  
Vladimir Anatolyevich Zakharov
Keyword(s):  
Model Checking ◽  
Temporal Logic ◽  
Linear Time ◽  
Complete Solution ◽  
Reactive Systems ◽  
Expressive Power ◽  
Regular Languages ◽  
Specification Languages ◽  
Temporal Logics ◽  
Emptiness Problem

Sequential reactive systems are computer programs or hardware devices which process the flows of input data or control signals and output the streams of instructions or responses. When designing such systems one needs formal specification languages capable of expressing the relationships between the input and output flows. Previously, we introduced a family of such specification languages based on temporal logics $LTL$, $CTL$ and $CTL^*$ combined with regular languages. A characteristic feature of these new extensions of conventional temporal logics is that temporal operators and basic predicates are parameterized by regular languages. In our early papers, we estimated the expressive power of the new temporal logic $Reg$-$LTL$ and introduced a model checking algorithm for $Reg$-$LTL$, $Reg$-$CTL$, and $Reg$-$CTL^*$. The main issue which still remains unclear is the complexity of decision problems for these logics. In the paper, we give a complete solution to satisfiability checking and model checking problems for $Reg$-$LTL$ and prove that both problems are Pspace-complete. The computational hardness of the problems under consideration is easily proved by reducing to them the intersection emptyness problem for the families of regular languages. The main result of the paper is an algorithm for reducing the satisfiability of checking $Reg$-$LTL$ formulas to the emptiness problem for Buchi automata of relatively small size and a description of a technique that allows one to check the emptiness of the obtained automata within space polynomial of the size of input formulas.

scholarly journals MODEL CHECKING EARLY REQUIREMENTS SPECIFICATIONS IN ALLOY

2018 ◽  
Vol 54 (3A) ◽  
pp. 163
Author(s):  
Ton Long Phuoc
Keyword(s):  
Software Engineering ◽  
Model Checking ◽  
Source Code ◽  
Specification Language ◽  
Specification Languages ◽  
Architectural Pattern ◽  
Mvc Model ◽  
Requirements Specifications ◽  
Model View Controller ◽  
Model View

Automation generated source code and verifying are essential sector for software engineering. There are many ways to generate source code and verify from the specification languages. In this paper, we propose an approach that automatically generated code from a specification language Alloy. From this specification language, we will describe how to translate from one language to the Java source. An application in this paper is a gardening game program. Applied after the findings will be organized according to the MVC (Model-View-Controller) architectural pattern. Besides, we will also verify the identity of the structure of the application and the content of the Alloy specification. We built an tool as GmDSL, we have verified the aplication in GmDSL. The application was created from the tool also shows the correctness of the early constraints. Simultaneously, we also compares be verified through the GmDSL tool with NuSVM tool.

scholarly journals Data flow analysis as model checking

1990 ◽  
Vol 19 (325) ◽  
Author(s):  
Bernhard Steffen
Keyword(s):  
Model Checking ◽  
Modal Logic ◽  
Data Flow ◽  
Flow Analysis ◽  
Specific Model ◽  
Specification Language ◽  
Model Checker ◽  
Modal Formula ◽  
Data Flow Analysis ◽  
Flow Graphs

The paper develops the idea that modal logic provides an appropriate framework for the specification of data flow analysis (DFA) algorithms as soon as programs are represented as models of the logic. This can be exploited to construct a DFA-<strong>generator</strong> that generates efficient DFA-algorithms from modal specifications by partially evaluating a specific model checker wrt the specifying modal formula. Moreover, the use of a modal logic as specification language for DFA-algorithms supports the compositional development of specifications and structured proofs of properties of DFA-algorithms. These ideas are applied to the problem of determining optimal computation points within flow graphs.

Sign in / Sign up

Export Citation Format

Share Document