Academia.eduAcademia.edu

Outline

Title
Abstract
Figures
References
All Topics
Computer Science

Using the Dedan Program

Profile image of Wiktor B DaszczukWiktor B Daszczuk

2019, Studies in Computational Intelligence

https://doi.org/10.1007/978-3-030-12835-7_6
visibility

…

description

11 pages

link

1 file

Abstract

The structure of the Dedan program is presented in Fig. 6.1. The central module Model contains the representation of a verified system. This module converts between the server view and the agent view of the system. The Input module allows reading the model from the file in IMDS notation or XML file. The Output module saves the model in various formats:

Figures (8)
Fig. 6.1 The structure of the Dedan program
Fig. 6.1 The structure of the Dedan program
Fig. 6.2 Main window of the Dedan program
Fig. 6.2 Main window of the Dedan program
Fig. 6.3 Definition of actual parameters and initial state of a server (left) and graphical server design (right)
Fig. 6.3 Definition of actual parameters and initial state of a server (left) and graphical server design (right)
Fig. 6.5 Counterexample viewed as configuration sequence
Fig. 6.5 Counterexample viewed as configuration sequence
execute: the next server state and the next agent message (if any). Clicking this box causes the execution of the action and the output configuration becomes current. A entire LTS can be observed as a graph (Fig. 6.7). Simulation is possible over LTS. On the left, the current configuration is shown textually and a list of next configurations is listed, each with the matching input pair of the action, leading to the next configuration. Clicking one of the next configurations makes it current. On the right, each configuration is shown in a box, and possible next configurations are appointed by arrows. The current configuration is distinguished with a green box. and the red arrows lead to the next configurations. Matching pairs are displayed on the top of each possible next configuration on a pink background. Clicking any
execute: the next server state and the next agent message (if any). Clicking this box causes the execution of the action and the output configuration becomes current. A entire LTS can be observed as a graph (Fig. 6.7). Simulation is possible over LTS. On the left, the current configuration is shown textually and a list of next configurations is listed, each with the matching input pair of the action, leading to the next configuration. Clicking one of the next configurations makes it current. On the right, each configuration is shown in a box, and possible next configurations are appointed by arrows. The current configuration is distinguished with a green box. and the red arrows lead to the next configurations. Matching pairs are displayed on the top of each possible next configuration on a pink background. Clicking any
visible configuration results in a detailed display of its data and enables taking this configuration as current. The button on upper right corner of the main window converts the model to the agent view, and displays it in a separate window. The shape of this window is similar to the main window (the server view), with the difference that formal and actual parameters are attributed to the agent types and agent variables rather than to servers. Of course, states and services are still attributed to server types. It is shown in Fig. 6.8.
visible configuration results in a detailed display of its data and enables taking this configuration as current. The button on upper right corner of the main window converts the model to the agent view, and displays it in a separate window. The shape of this window is similar to the main window (the server view), with the difference that formal and actual parameters are attributed to the agent types and agent variables rather than to servers. Of course, states and services are still attributed to server types. It is shown in Fig. 6.8.
Fig. 6.8 The agent view
Fig. 6.8 The agent view

Related papers

Two-stage agent program verification
Louise Dennis

Journal of Logic and Computation, 2015

We describe an extension to the AJPF agent program model-checker so that it may be used to generate models for input into other, non-agent, model-checkers. We motivate this adaptation, arguing that it potentially improves the efficiency of the modelchecking process and provides access to richer property specification languages. We illustrate the approach by describing the export of AJPF program models to both the SPIN and Prism model-checkers. We also investigate, experimentally, the effect the process has on the overall efficiency of model-checking.

View PDFchevron_right
Verification of an SDL Specification- a Case Study
Zmago Brezocnik

Elektrotehniski Vestnik, 2005

This paper presents practical experience gained by an attempt to mechanically extract a model of the Inres service with the go-back-n extension and verify it with the use of simulation and formal verification based on the model checking technique. The service specification is written in the Specification and Description Language (SDL). The model is obtained mechanically with the application of the sdl2if and if2pml tools. Transformation to discrete-time Promela is followed by simulation and an example of formal verification of a property described in Linear Temporal Logic (LTL) with the Spin model checker. Description of each step of the process is followed with the noticed shortcomings of the procedure, limitations of the tools and discovered faults in the specification of the service. We conclude with a discussion of further research activities and some results from the domain of mechanical extraction of models from SDL system specifications.

View PDFchevron_right
Automatic verification of deontic properties of multi-agent systems
Franco Raimondi

2004

We present an algorithm and its implementation for the verification of correct behaviour and epistemic states in multiagent systems. The verification is performed via model checking techniques based on obdd's. We test our implementation by means of a communication example: the bit transmission problem with faults.

View PDFchevron_right
A Translator of Java Programs to TADDs
Andrzej Zbrzezny

Fundamenta Informaticae, 2009

The model checking tools Uppaal and VerICS accept a description of a network of Timed Automata with Discrete Data (TADDs) as input. Thus, to verify a concurrent program written in Java by means of these tools, first a TADD model of the program must be build. Therefore, we have developed the J2TADD tool that translates a Java program to a network of TADDs; the paper presents this tool.

View PDFchevron_right
Towards a Multi-Formalism Model Checker Based on SDES Description
Behrang Mehrparvar

The role of critical concurrent systems is increasing in today ICT systems. Formal modeling techniques and tools provide adequate and comprehensive solutions for verification of these systems. High-level modeling formalisms support system designers to express systems in an abstract manner, using multiple formalisms to model various aspects of complex systems, eases the process of system modeling. A multi-formalism model checker is intended to provide various methods of model checking regardless of the formalism defining the model. The aim has been to use SDES description as the base of a multi-formalism model checking framework. By translation from various high-level models, the interface model is used for generating low-level state spaces. In this paper, a new multi-formalism model checking approach is introduced based on SDES description as an interface formalism. Furthermore, an architecture for a multiformalism model checking component integrated in PDETool, an existing modeling tool, is provided.

View PDFchevron_right
A Tooled Approach for Designing Executable and Verifiable Modeling Languages
Christophe Dony

Insight, 2015

View PDFchevron_right
Verification of JADE Agents Using ATL Model Checking
Laura Florentina Stoica

International Journal of Computers Communications & Control, 2015

It is widely accepted that the key to successfully developing a system is to produce a thorough system specification and design. This task requires an appropriate formal method and a suitable tool to determine whether or not an implementation conforms to the specifications. In this paper we present an advanced technique to analyse, design and debug JADE software agents, using Alternating-time Temporal Logic (ATL) which is interpreted over concurrent game structures, considered as natural models for compositions of open systems. In development of the proposed solution, we will use our original ATL model checker. In contrast to previous approaches, our tool permits an interactive or programmatic design of the ATL models as state-transition graphs, and is based on client/server architecture: ATL Designer, the client tool, allows an interactive construction of the concurrent game structures as a directed multi-graphs and the ATL Checker, the core of our tool, represents the server part ...

View PDFchevron_right
Verification methodology for DEVS models
Hesham Saadawi

T he author has granted a non exclusive license allow ing Library and A rchives C anada to reproduce, publish, archive, preserve, conserve, com m unicate to the public by telecom m unication or on the Internet, loan, distrbute and sell theses w orldw ide, fo r com m ercial or non com m ercial purposes, in m icroform , paper, ele ctron ic and /or any other form ats. AVIS: L 'auteur a accorde une licence non exclusive perm ettant a la B ibliotheque et A rchives C anada de reproduire, publier, archiver, sauvegarder, conserver, transm ettre au public par telecom m unication ou par I'lnternet, preter, d istribuer e t vendre des theses partout dans le monde, a des fins co m m erciales ou autres, sur su pport m icroform e, papier, electronique et/ou autres form ats. Bien que ces form ulaires aient inclus dans la pagination, il n'y aura aucun contenu m anquant.

View PDFchevron_right
Integration of Bounded Model Checking and Deductive Verification
Carsten Sinz

Lecture Notes in Computer Science, 2012

Modular deductive verication of software systems is a complex task: the user has to put a lot of eort in writing module specications that t together when verifying the system as a whole. In this paper, we propose a combination of deductive verication and software bounded model checking (SBMC), where SBMC is used to support the user in the specication and verication process, while deductive verication provides the nal correctness proof. SMBC provides early as well as precise feedback to the user. Unlike modular deductive verication, the SBMC approach is able to check annotations beyond the boundaries of a single module even if other relevant modules are not annotated (yet). This allows to test whether the dierent module specications in the system match the implementation at every step of the specication process.

View PDFchevron_right
Lecture 10: Practical BDI Programming II Autonomous Agents and Multiagent Systems DIS, La Sapienza - PhD Course
Sebastian Sardina

2000

View PDFchevron_right

References (3)

  1. Alur, R., & Dill, D. L. (1994). A theory of timed automata. Theoretical Computer Science, 126(2), 183-235. https://doi.org/10.1016/0304-3975(94)90010-8.
  2. Clarke, E. M., Grumberg, O., & Peled, D. (1999). Model checking. Cambridge, MA: MIT Press. ISBN: 978-0-262-03270-4.
  3. Holzmann, G. J. (1995). Tutorial: Proving properties of concurrent systems with SPIN. In 6th International Conference on Concurrency Theory, CONCUR'95, Philadelphia, PA (pp. 453- 455), 21-24 August, 1995. Berlin, Heidelberg: Springer. https://doi.org/10.1007/3-540-60218- 6_34.

Related papers

Rybu: Imperative-style Preprocessor for Verification of Distributed Systems in the Dedan Environment
Jan Michalski, Wiktor B Daszczuk

Software Engineering Research for the Practice, 2017

Integrated Model of Distributed Systems (IMDS) is developed for specification and verification of distributed systems, and verification against deadlocks. On the basis of IMDS, Dedan verification environment was prepared. Universal deadlock detection formulas allow for automatic verification, without any knowledge of a temporal logic, which simplifies the verification process. However, the input language, following the rules of IMDS, seems to be exotic for many users. For this reason Rybu preprocessor was created. Its purpose is to build large models in imperative-style language, on much higher abstraction level.

View PDFchevron_right
Automatic verification of deontic interpreted systems by model checking via OBDD's
Franco Raimondi

2004

Abstract. We present an algorithm for the verification of multiagent systems specified by means of a modal logic that includes a temporal, an epistemic, and a deontic operator. Verification is performed by model checking on OBDD's. We present an implementation of the algorithm and report on experimental results for the bit transmission problem with faults.

View PDFchevron_right
Formal Specification and Verification of System of Systems Using UPPAAL: A Case Study of a Defensive Missile Systems
Joonha Jang

Journal of Communications, 2017

-In this paper, we specify and verify System of Systems (SoS) using Formal Methods. As software evolved, its size and weight increased. This makes the embedded system more complex. This trend led to the concept of SoS. SoS is an integrated system, which has systems as components. This has a very large system complexity. At this time, the total system complexity is larger than each sum. Due to the complexity of the system it is very difficult to evaluate and develop the SoS appropriately. So we use system engineering. The advantages of system engineering are as follows. First, it is possible to clarify the requirements of the independent systems and the SoS requirements. Second, it is not only possible to demonstrate and evaluate independently the requirements for each system, but also to demonstrate and evaluate requirements in a SoS. At the same time, system engineering has the following challenges. First, it is difficult to simulate and model from the perspective of SoS. Second, it is difficult to verify the time constraints of SoS. In this work we try to solve this challenge using formal methods. We use model checking among Formal Methods. And we model and verify the system using a tool called UPPAAL. The reason for using UPPAAL is because the system definition of it is suitable for SoS. And because UPPAAL is suitable for verifying real-time systems. In this study, we do modelling and verify the behavior of Defensive Missile System(DMS). Through this we objectively verified the time constraints of SoS using formal methods. And we verified interoperability of DMS. And we have verified that the procedures of the DMS are logically error free and the time constraints that the DMS has. The DMS model, an implementation of our study, is reusable and extensible.

View PDFchevron_right
Run-time model checking of interaction and deontic models for multi-agent systems
David Robertson

Proceedings of the fifth international joint conference on Autonomous agents and multiagent systems, 2006

View PDFchevron_right
Model checking agentspeak
Michael Fisher

2003

This paper introduces AgentSpeak(F), a variation of the BDI logic programming language AgentSpeak(L) intended to permit the model-theoretic verification of multi-agent systems. After briefly introducing AgentSpeak(F) and discussing its relationship to AgentSpeak(L), we show how AgentSpeak(F) programs can be transformed into Promela, the model specification language for the Spin model-checking system. We also describe how specifications written in a simplified form of BDI logic can be transformed into Spin-format linear temporal logic formulae. With our approach, it is thus possible to automatically verify whether or not multi-agent systems implemented in AgentSpeak(F) satisfy specifications expressed as BDI logic formulae. We illustrate our approach with a short case study, in which we show how BDI properties of a simulated auction system implemented in AgentSpeak(F) were verified.

View PDFchevron_right

Related topics

  • Computer Science
  • Computer Science and Information...

    • Cited by

    Static and Dynamic Verification of Space Systems Using Asynchronous Observer Agents
    Wiktor B Daszczuk

    Sensors, 2021

    Formal verification of distributed systems is essential, especially in mission-critical systems that cannot be restarted. Such are space systems in which satellites read sensor values and autonomously make actuator decisions based on them, and ground services only set general patterns of behavior. The verification formalism should correspond to the essential characteristics of a distributed system, such as node autonomy and asynchrony of actions and communication, as in our Integrated Model of Distributed Systems (IMDS). It is also crucial that the formalism allows for finding partial deadlocks and checking partial termination, where only a subset of the system nodes is involved while the rest can perform their own tasks at the same time. This article presents the idea of using monitoring agents—observers prepared in the IMDS formalism. Observers check the state of individual system components by polling, allowing verification without knowing the global state of the system. Such an ...

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved