István Majzik

Budapest University of Technology and Economics, Department of Measurement and Information Systems, Faculty Member

Followers

Following

Co-authors

Public Views

Researcher and manager of national and EU RD projects on software verification, safety-critical computer systems, dependable computing, and formal methods. Lecturer for subjects "Formal Methods", "Software Verification Techniques", "Design for Dependability", and "Real-Time and Safety-Critical Systems".

less

Uploads

Papers by István Majzik

Ontology-Based Test Data Generation Using Metaheuristics

Proceedings of the 8th International Conference on Informatics in Control, Automation and Robotics, 2011

A Proposal of an Example and Experiments Repository to Foster Industrial Adoption of Formal Methods

Lecture Notes in Computer Science, 2018

Formal methods (in a broad sense) have been around almost since the beginning of computer science... more Formal methods (in a broad sense) have been around almost since the beginning of computer science. Nonetheless, there is a perception in the formal methods community that take-up by industry is low considering the potential benefits. We take a look at possible reasons and give candidate explanations for this effect. To address the issue, we propose a repository of industry-relevant example problems with an accompanying open data storage for experiment results in order to document, disseminate and compare exemplary solutions from formal model based methods. This would allow potential users from industry to better understand the available solutions and to more easily select and adopt a formal method that fits their needs. At the same time, it would foster the adoption of open data and good scientific practice in this research field.

Workflow-Driven Tool Integration Using Model Transformations

Lecture Notes in Computer Science, 2010

Integration Test Generation and Formal Verification for Distributed Controllers

Proceedings of the 30th Minisymposium

Software-intensive distributed controllers are becoming increasingly prevalent, among others, als... more Software-intensive distributed controllers are becoming increasingly prevalent, among others, also in railway interlocking systems (RIS). As such systems carry out critical tasks, their systematic verification and testing are a must, which can be supported by formal methods. This paper presents a verification and testing approach for a distributed RIS subsystem using hidden formal methods. The subsystem's functional behavior is modeled using statechart components defined in a high-level UML-based modeling language, which are integrated according to sound execution and interaction semantics defined by the RIS protocol. The emergent model is automatically mapped into input formalisms of model checker back-ends. Integration tests for the system implementation are derived according to various modelbased coverage criteria using the model checker back-ends and generated properties. The approach is implemented in our open source Gamma Statechart Composition Framework.

downloadDownload free PDF

System architecture synthesis for performability by logic solvers

Proceedings of the 25th International Conference on Model Driven Engineering Languages and Systems

In model-based systems engineering, system architectures often have to make compromises to meet h... more In model-based systems engineering, system architectures often have to make compromises to meet hard constraints of functional and extra-functional requirements while optimizing for a target objective. Design space exploration (DSE) techniques have been developed to automatically propose candidate architectures over an extremely large design and configuration space. (1) Meta-heuristic exploration algorithms are often used to provide practical, besteffort solutions for DSE, but they lack any guarantees of completeness or optimality. (2) Logic synthesis based approaches may offer strong theoretical guarantees, but frequently face scalability issues. In the paper, we propose two logic solver-based approaches to evaluate complex design spaces by using partial models in order to find an optimal solution with respect to performability objectives. One approach uses performability analysis as a post-filtering of valid system architecture candidates, while the other approach uses performability analysis for guiding the actual search over partial models. We evaluate both approaches on an interferometry mission architecture case study using view transformations for performability analysis and compare our approach with a well-known DSE framework based on meta-heuristic search. CCS CONCEPTS • Software and its engineering → Architecture description languages; Search-based software engineering; • Computer systems organization → Dependable and fault-tolerant systems and networks; • Theory of computation → Discrete optimization.

format_quotePerformability metrics measure expected scientific data coverage based on reliability during failures within a constrained observation time.format_quote

downloadDownload free PDF

Timed Automata Verification Using Interpolants

The behavior of safety critical systems is often constrained by real time requirements. To model ... more The behavior of safety critical systems is often constrained by real time requirements. To model time dependent behavior and enable formal verification, timed automata are widely used as a formal model of such systems. However, due to real-valued clock variables, the state space of these systems is not finite, thus model checkers for timed automata are usually based on zone abstraction. The coarseness of the abstraction profoundly impacts performance of the analysis. In this paper, we propose a lazy abstraction algorithm based on interpolation for zones to enable efficient reachability checking for timed automata. In order to efficiently handle zone abstraction, we define interpolation in terms of difference bound matrices. We extend the notion of zone interpolants to sequences of transitions of a timed automaton, thus enabling the use of zone interpolants for abstraction refinement.

downloadDownload free PDF

Constructing Dependability Analysis Models of Reconfigurable Production Systems

2018 IEEE 14th International Conference on Automation Science and Engineering (CASE), 2018

Model-driven engineering methodologies are often used for the design and integration of the softw... more Model-driven engineering methodologies are often used for the design and integration of the software and hardware components in automated production systems. Architecture models in general purpose or domain specific modeling languages allow the modular and systematic construction of formal analysis models for the evaluation of dependability and performability. The on-line reconfiguration and fault handling actions in the system introduce changes in the architecture and parameters, and thus result in a multi-phased operation. We propose a mission automaton formalism to describe reconfigurations, fault handling and parameter changes over architecture models. By maintaining the architecture model, which is modified by the reconfigurations, along with the corresponding analysis models, a stochastic phased-mission system (PMS) is obtained and solved for dependability.

Saturation Enhanced with Conditional Locality: Application to Petri Nets

The saturation algorithm for symbolic state space generation has proved to be an efficient way to... more The saturation algorithm for symbolic state space generation has proved to be an efficient way to tackle the state space explosion problem in the verification of concurrent, asynchronous systems. Since its original publication in 2001, several variants and extensions have been introduced. The reason for altering the algorithm in these variants is often specific to how it handles transitions. Saturation heavily relies on the notion of locality: transitions tend to affect only some of the state variables. The saturation effect, however, can be achieved and even enhanced with a weaker notion of locality, which we call conditional locality. In this paper, we define a generalized version of the saturation algorithm (GSA) for multi-valued decision diagrams that works with conditional locality and show that it enables the direct usage of transition relations that previously required a specialized algorithm such as variants of constrained saturation. Focusing on Petri nets, we also empirica...

Design and Evaluation of a Safe Driver Machine Interface

International journal of performability engineering, 2009

Driver Machine Interface (DMI) is a slave unit of the train onboard computer in the ERTMS automat... more Driver Machine Interface (DMI) is a slave unit of the train onboard computer in the ERTMS automatic train control system. The SAFEDMI project aimed at the devel- opment of a DMI which fulfills the requirements of Safety Integrity Level 2 according to the CENELEC development standards. The main challenges were (i) the reduction of the hardware complexity and costs by implementing the safety mechanisms in software and (ii) provide a safe and secure wireless communication interface to support diagnostics and maintenance. This paper presents the requirements, the design of the architecture and the wireless communication protocol, and the evaluation of the applied solutions.

downloadDownload free PDF

Theta: A framework for abstraction refinement-based model checking

2017 Formal Methods in Computer Aided Design (FMCAD), 2017

In this paper, we present THETA, a configurable model checking framework. The goal of the framewo... more In this paper, we present THETA, a configurable model checking framework. The goal of the framework is to support the design, execution and evaluation of abstraction refinement-based reachability analysis algorithms for models of different formalisms. It enables the definition of input formalisms, abstract domains, model interpreters, and strategies for abstraction and refinement. Currently it contains front-end support for transition systems, control flow automata and timed automata. The built-in abstract domains include predicates, explicit values, zones and their combinations, along with various refinement strategies implemented for each. The configurability of the framework allows the integration of several abstraction and refinement methods, this way supporting the evaluation of their advantages and shortcomings. We demonstrate the applicability of the framework by use cases for the safety checking of PLC, hardware, C programs and timed automata models.

downloadDownload free PDF

Industrial applications of the PetriDotNet modelling and analysis tool

Science of Computer Programming, 2018

Since their invention, Petri nets have provided modelling and analysis methods to support the des... more Since their invention, Petri nets have provided modelling and analysis methods to support the design of correct, reliable and robust systems. This motivated our work to develop PetriDotNet, a Petri net editor and analysis tool. In this paper we overview the supported modelling formalisms and the analysis methods included in PetriDotNet. Next, we present eight different industrial case studies, demonstrating the wide variety of scenarios where Petri nets and PetriDotNet can help the design, development and analysis of industrial systems. Our original goal with PetriDotNet was to provide an educational tool to our students, however our efforts led to a framework being able to serve both academic and industrial needs.

downloadDownload free PDF

Configurable verification of timed automata with discrete variables

Acta Informatica, 2020

Algorithms and protocols with time dependent behavior are often specified formally using timed au... more Algorithms and protocols with time dependent behavior are often specified formally using timed automata. For practical real-time systems, besides real-valued clock variables, these specifications typically contain discrete data variables with nontrivial data flow. In this paper, we propose a configurable lazy abstraction framework for the location reachability problem of timed automata that potentially contain discrete variables. Moreover, based on our previous work, we uniformly formalize in our framework several abstraction refinement strategies for both clock and discrete variables that can be freely combined, resulting in many distinct algorithm configurations. Besides the proposed refinement strategies, the configurability of the framework allows the integration of existing efficient lazy abstraction algorithms for clock variables based on $${\textit{LU}}$$ LU -bounds. We demonstrate the applicability of the framework and the proposed refinement strategies by an empirical evalu...

downloadDownload free PDF

Mixed-semantics composition of statecharts for the component-based design of reactive systems

Software and Systems Modeling, 2020

The increasing complexity of reactive systems can be mitigated with the use of components and com... more The increasing complexity of reactive systems can be mitigated with the use of components and composition languages in model-driven engineering. Designing composition languages is a challenge itself as both practical applicability (support for different composition approaches in various application domains), and precise formal semantics (support for verification and code generation) have to be taken into account. In our Gamma Statechart Composition Framework, we designed and implemented a composition language for the synchronous, cascade synchronous and asynchronous composition of statechart-based reactive components. We formalized the semantics of this composition language that provides the basis for generating composition-related Java source code as well as mapping the composite system to a back-end model checker for formal verification and model-based test case generation. In this paper, we present the composition language with its formal semantics, putting special emphasis on de...

format_quoteGamma Composition Language facilitates component heterogeneity and supports three composition semantics: asynchronous-reactive, synchronous-reactive, and cascade.format_quote

downloadDownload free PDF

Model Checking-based Software-FMEA: Assessment of Fault Tolerance and Error Detection Mechanisms

Periodica Polytechnica Electrical Engineering and Computer Science, 2017

Failure Mode and Effects Analysis (FMEA) is a systematic technique to explore the possible failur... more Failure Mode and Effects Analysis (FMEA) is a systematic technique to explore the possible failure modes of individual components or subsystems and determine their potential effects at the system level. Applications of FMEA are common in case of hardware and communication failures, but analyzing software failures (SW-FMEA) poses a number of challenges. Failures may originate in permanent software faults commonly called bugs, and their effects can be very subtle and hard to predict, due to the complex nature of programs. Therefore, a behavior-based automatic method to analyze the potential effects of different types of bugs is desirable. Such a method could be used to automatically build an FMEA report about the fault effects, or to evaluate different failure mitigation and detection techniques. This paper follows the latter direction, demonstrating the use of a model checking-based automated SW-FMEA approach to evaluate error detection and fault tolerance mechanisms, demonstrated on...

downloadDownload free PDF

Verification of a Real-Time Safety-Critical Protocol Using a Modelling Language with Formal Data and Behaviour Semantics

Lecture Notes in Computer Science, 2014

Formal methods have an important role in ensuring the correctness of safety critical systems. How... more Formal methods have an important role in ensuring the correctness of safety critical systems. However, their application in industry is always cumbersome: the lack of experts and the complexity of formal languages prevents the efficient application of formal verification techniques. In this paper we take a step in the direction of making formal modelling simpler by introducing a framework which helps designers to construct formal models efficiently. Our formal modelling framework supports the development of traditional transition systems enriched with complex data types with type checking and type inference services, time dependent behaviour and timing parameters with relations. In addition, we introduce a toolchain to provide formal verification. Finally, we demonstrate the usefulness of our approach in an industrial case study.

format_quoteA counterexample revealed that message loss can prevent connection establishment, highlighting vulnerabilities in the protocol's first design.format_quote

downloadDownload free PDF

Component-wise incremental LTL model checking

Formal Aspects of Computing, 2016

Efficient symbolic and explicit-state model checking approaches have been developed for the verif... more Efficient symbolic and explicit-state model checking approaches have been developed for the verification of linear time temporal logic (LTL) properties. Several attempts have been made to combine the advantages of the various algorithms. Model checking LTL properties usually poses two challenges: one must compute the synchronous product of the state space and the automaton model of the desired property, then look for counterexamples that is reduced to finding strongly connected components (SCCs) in the state space of the product. In case of concurrent systems, where the phenomenon of state space explosion often prevents the successful verification, the so-called saturation algorithm has proved its efficiency in state space exploration. This paper proposes a new approach that leverages the saturation algorithm both as an iteration strategy constructing the product directly, as well as in a new fixed-point computation algorithm to find strongly connected components on-the-fly by incre...

downloadDownload free PDF

Towards System-Level Testing with Coverage Guarantees for Autonomous Vehicles

Since safety-critical autonomous vehicles need to interact with an immensely complex and continuo... more Since safety-critical autonomous vehicles need to interact with an immensely complex and continuously changing environment, their assurance is a major challenge. While systems engineering practice necessitates assurance on multiple levels, existing research focuses dominantly on component-level assurance while neglecting complex system-level traffic scenarios. In this paper, we aim to address the system-level testing of the situationdependent behavior of autonomous vehicles by combining various model-based techniques on different levels of abstraction. (1) Safety properties are continuously monitored in challenging test scenarios (obtained in simulators or field tests) using graph query and complex event processing techniques. To precisely quantify the coverage of an existing test suite with respect regulations of safety standards, (2) we provide qualitative abstractions of causal, temporal, or geospatial data recorded in individual runs into situation graphs, which allows to systematically measure systemlevel situation coverage (on an abstract level) wrt. safety concepts captured by domain experts. Moreover, (3) we can systematically derive new challenging (abstract) situations which justifiably lead to runtime behavior which has not been tested so far by adapting consistent graph generation techniques, thus increasing situation coverage. Finally, (4) such abstract test cases are concretized so that they can be investigated in a real or simulated context.

downloadDownload free PDF

Design and Evaluation of a Safe Driver Machine Interface

by Stěpán Klapka and István Majzik

International journal of performability engineering, 2009

downloadDownload free PDF

The Gamma statechart composition framework

Proceedings of the 40th International Conference on Software Engineering: Companion Proceeedings

The Gamma Statechart Composition Framework is an integrated tool to support the design, verificat... more The Gamma Statechart Composition Framework is an integrated tool to support the design, verification and validation as well as code generation for component-based reactive systems. The behavior of each component is captured by a statechart, while assembling the system from components is driven by a domain-specific composition language. Gamma automatically synthesizes executable Java code extending the output of existing statechart-based code generators with composition related parts, and it supports formal verification by mapping composite statecharts to a back-end model checker. Execution traces obtained as witnesses during verification are back-annotated as test cases to replay an error trace or to validate external code generators. Tool demonstration video: https://youtu.be/ng7lKd1wlDo CCS CONCEPTS • Theory of computation → Verification by model checking; • Software and its engineering → System modeling languages; Formal software verification;

downloadDownload free PDF

Automatic Verication of a Behavioural Subset of UML Statechart Diagrams Using the SPIN

Statechart Diagrams provide a graphical notation for describing dy- namic aspects of system behav... more Statechart Diagrams provide a graphical notation for describing dy- namic aspects of system behaviour within the Unied Modelling Language (UML). In this paper we present a translation from a subset of UML State- chart Diagrams - covering essential aspects of both concurrent behaviour, like sequentialisation, parallelism, non-determinism and priority, and state renement - into PROMELA, the specication language of the SPIN model checker. SPIN is one of the most advanced analysis and verication tools available nowadays. Our translation allows for the automatic verication of UML Statechart Diagrams. The translation is simple, proven correct, and promising in terms of state space representation eciency.

István Majzik

Uploads

Papers by István Majzik

Log In