Complexity of Many-Valued Logics

As is the case for other logics, a number of complexity-related questions can be posed in the context of many-valued logic. Some of these, such as the complexity of the sets of satisfiable and valid formulas in various logics, are completely standard; others only make sense in a many-valued context. In this overview I concentrate on two kinds of complexity problems related to many-valued logic: first, I discuss the complexity of the membership problem in various languages, such as the satisfiable, respectively, the valid formulas in some well-known logics. Second, I discuss the size of representations of many-valued connectives and quantifiers, because this has a direct impact on the complexity of many kinds of deduction systems. I include results on both propositional and on first-order logic

HATS: Highly Adaptable and Trustworthy Software using Formal Models

The HATS project develops a formal method for the design, analysis, and implementation of highly adaptable software systems that are characterized by high demand on trustworthiness. Existing modeling formalisms leave gap between highly abstract, largely structural models and executable code on the implementation level. HATS aims to close this gap with an object-oriented, executable modeling language for adaptable, concurrent software components. It comes with tool suite based on analysis methods developed hand in hand with the language

Symbolic Fault Injection

Computer systems that are dependable in the presence of faults are increasingly in demand. Among available fault tolerance mechanisms, software-implemented hardware fault tolerance (SIHFT) is constantly gaining in popularity, because of its cost efficiency and flexibility. Fault tolerance mechanisms are often validated using fault injection, comprising a variety of techniques for introducing faults into a system. Traditional fault injection techniques, however, suffer from a number of drawbacks, notably lack of coverage (impossibility to exhaust all test cases) and the failure toactivate enough injected faults. In this paper we present a new approach called symbolic fault injection which is targeted at validation of SIHFT mechanisms and is based on the concept of symbolic execution of programs. It can be seen as the extension of a formal technique for formal program verification that makes it possible to evaluate the consequences of all possible faults (of a certain kind) in given memory locations for all possible system inputs. This makes it possible to formally prove properties of fault tolerance mechanisms. The new method for symbolic fault injection has been prototypically implemented on the basis of an industrial-strength formal verification system and we demonstrate its viability by proving that a CRC implementation detects all possible single bit-flips