scholarly journals Using formal methods for autonomous systems: Five recipes for formal verification

Author(s):  
Matt Luckcuck

Formal Methods are mathematically-based techniques for software design and engineering, which enable the unambiguous description of and reasoning about a system’s behaviour. Autonomous systems use software to make decisions without human control, are often embedded in a robotic system, are often safety-critical, and are increasingly being introduced into everyday settings. Autonomous systems need robust development and verification methods, but formal methods practitioners are often asked: Why use Formal Methods for Autonomous Systems? To answer this question, this position paper describes five recipes for formally verifying aspects of an autonomous system, collected from the literature. The recipes are examples of how Formal Methods can be an effective tool for the development and verification of autonomous systems. During design, they enable unambiguous description of requirements; in development, formal specifications can be verified against requirements; software components may be synthesised from verified specifications; and behaviour can be monitored at runtime and compared to its original specification. Modern Formal Methods often include highly automated tool support, which enables exhaustive checking of a system’s state space. This paper argues that Formal Methods are a powerful tool for the repertoire of development techniques for safe autonomous systems, alongside other robust software engineering techniques.

1989 ◽  
Vol 12 (3) ◽  
pp. 317-356
Author(s):  
David C. Rine

Partitioning and allocating of software components are two important parts of software design in distributed software engineering. This paper presents two general algorithms that can, to a limited extent, be used as tools to assist in partitioning software components represented as objects in a distributed software design environment. One algorithm produces a partition (equivalence classes) of the objects, and a second algorithm allows a minimum amount of redundancy. Only binary relationships of actions (use or non-use) are considered in this paper.


2016 ◽  
Vol 12 (07) ◽  
pp. 24 ◽  
Author(s):  
Anzhelika Parkhomenko ◽  
Olga Gladkova ◽  
Alexandr Sokolyanskii ◽  
Vladislav Shepelenko ◽  
Yaroslav Zalyubovskiy

Development of remote laboratory for embedded systems complex hardware/software design is an actual task, because the challenges existing in this area, require qualitatively new techniques, technologies and tools of design. By using the possibilities of remote labs and reusable hardware/software components, developer can more optimally organize the project and realize it in a shorter time. Development and usage of remote labs for designers can give new opportunities and ways for accumulation and study of existing design experience and ready solutions. On the other side, today, in the area of remote laboratories development are no common standards and approaches. Different developers offer different solutions for laboratory functionality, interfaces, a set of experiments, etc. At the same time, there are a number of ready-made solutions that can be used repeatedly for more optimal development and rapid integration with existing projects. Therefore, investigation and implementation of re-use methodology and its practical realization is an urgent task. The paper presents the structural components and API of remote laboratory RELDES, proposed for reuse in other projects for creation of mobile applications, new clients or services. Open questions of RESTful API documenting are also discussed.


Author(s):  
SOPHIE RENAULT ◽  
PIERRE DERANSART

Among the various tasks involved in SE & KE, requirements engineering, specification, prototyping, and validation are regarded as crucial since they decide whether a software system fulfills the users’ expectations. Formal methods provide a rigorous framework to guaranteed. Logic Programming has been recently shown as a promising candidate support these tasks and some relevant features can be in that way captured and formally regarding these concerns. Nevertheless, formalism does need some explanation to let it be more readable and understandable. This paper focuses on a specification design method which mixes formal text (represented by a logic program) and comments (using either formal or informal assertions). By the design of a specification we refer to the intertwined tasks of describing the specification and improving it by the investigation of proofs. These proofs aim to verify the link between the specification and the comments, and are partly automated. Then we present our practical experience in the use of an interacti ve proof system. As an example, we show how this methodology is currently applied to the draft of standard Prolog.


1993 ◽  
Vol 25 (7) ◽  
pp. 815-839 ◽  
Author(s):  
JoséA. Mañas ◽  
Tomás de Miguel ◽  
Joaquín Salvachúa ◽  
Arturo Azcorra

Author(s):  
Michael Butler ◽  
Michael Leuschel ◽  
Stéphane Lo Presti ◽  
Phillip Turner

2010 ◽  
Vol 11 (1) ◽  
pp. 1-13 ◽  
Author(s):  
A. Jakimi ◽  
A. Sabraoui ◽  
E. Badidi ◽  
A. Salah ◽  
M. El Koutbi

Scenarios has become a popular technique for requirements elicitation and specification building. Since scenarios capture only partial descriptions of the system behavior, an approach for scenario composition and/or integration is needed to produce more complete specifications. The Unified Modeling Language (UML), which has become a standard notation for object-oriented modeling, provides a suitable framework for scenario acquisition using Use Case diagrams and Sequence or Collaboration diagrams. In this paper, we suggest an algorithmic and tool support for composing and integrating scenarios that are represented in form of sequence diagrams. We suggest four operators (;: sequential operator, ||: concurrent operator, ?: conditional operator and  * :iteration operator) to compose a set of scenarios that describe a use case of a given system. In this paper, we suggest also to apply the scenario approach to B2B systems (Business to Business). We propose to develop B2B systems as a three activities process deriving formal specifications and code skeletons from UML scenarios. Activities of this proposed process are generally automatic and are supported by a set of developed algorithms and tools.


Author(s):  
David Maplesden ◽  
John Hosking ◽  
John Grundy

In this chapter we describe the Design pattern modeling language, a notation supporting the specification of Design pattern solutions and their instantiation into UML design models. DPML uses a simple set of visual abstractions and readily lends itself to tool support. DPML Design pattern solution specifications are used to construct visual, formal specifications of Design patterns. DPML instantiation diagrams are used to link a Design pattern solution specification to instances of a UML model, indicating the roles played by different UML elements in the generic Design pattern solution. A prototype tool is described, together with an evaluation of the language and tool.


Sign in / Sign up

Export Citation Format

Share Document