Search

We study a sound verification method for parametric component-based systems. The method uses a resource logic, a new formal specification language for distributed systems consisting of a finite yet unbounded number of components. The logic allows the description of architecture configurations coordinating instances of a finite number of types of components, by means of inductive definitions similar to the ones used to describe algebraic data types or recursive data structures. For parametric systems specified in this logic, we show that decision problems such as reaching deadlock or violating critical section are undecidable, in general. Despite this negative result, we provide for these decision problems practical semi-algorithms relying on the automatic synthesis of structural invariants allowing the proof of general safety properties. The invariants are defined using the WS κ S fragment of the monadic second order logic, known to be decidable by a classical automata-logic connection, thus reducing a verification problem to checking satisfiability of a WS κ S formula. • We introduce a logic-based language for describing sets of configurations of parameterized distributed systems. • The language uses predicate symbols to hierarchically decompose the system architecture into specific patterns. • We address a parametric safety problem i.e., checking that reachable configurations stay clear of error configurations. • We show that deadlock freedom and critical section violation problems are undecidable, even for simple architectures. • We develop a verification method that synthesizes parametric invariants described using a decidable fragment of MSO. [ABSTRACT FROM AUTHOR]

Owing to the massive growth in the storage demands of big data, cloud storage systems emerge at a historic moment, among which block-based cloud storage systems (BCSSs) are typical. Compared with traditional storage systems, BCSSs have many advantages, such as higher capacity, lower cost, and better scalability. BCSSs are also much more complex and error prone than traditional systems, and therefore, their reliability is a significant concern. Correctness is the most basic requirement for reliability. Therefore, it is of great significance to study BCSS program correctness verification to establish the theoretical basis for cloud storage systems. In this paper, we propose a novel framework based on separation logic (SL) to verify the correctness of BCSS management programs. We first construct a two-tier heap structure as the formal model of the storage architecture for BCSSs and present a modelling language based on this structure to describe the program execution. We then define assertion pairs to describe the properties of the two-tier structure. The two components of an assertion pair affect each other, producing several interesting properties. Finally, we propose a Hoare-style proof system to reason about BCSS programs and establish its soundness. We also demonstrate our proof system's uniqueness, usability, and scalability by verifying several real-world BCSS sample programs. In summary, this work presents a systematic approach that can be used to effectively solve BCSS program verification problems, and provides an SL-based logical modelling strategy, specifically to build its consistency with the actual behaviour of BCSSs. • Two-tier heap structure as a formal model of a block-based cloud storage system. • Separation logic-based assertion language with several new operators and connectives. • Hoare-style proof system to reason about BCSS management programs and its soundness. • Methods for formulation of specification rules to make them concise and effective. [ABSTRACT FROM AUTHOR]

Fidelity is one of the most widely used quantities in quantum information that measures the distance of two quantum states through a noisy channel, a kind of quantum operations. In this paper, we consider the model of quantum Markov chain (QMC), in which transitions are weighted by super-operators to characterize quantum operations and the initial quantum state is left parametric. A quantum analogy of probabilistic computation tree logic, called QCTL, is introduced to take into account fidelity, instead of probability measure, over QMC. The key to the model checking problem lies in computing the fidelity of the super-operator valued measure specified by a path formula in QCTL. It is minimized over all initial quantum states, which is intended for analyzing the system performance in the worst case. We achieve it by a reduction to quantifier elimination in the existential theory of the reals. The method is absolutely exact, so that model checking QCTL formulas against QMCs is proved to be decidable in exponential time. [ABSTRACT FROM AUTHOR]

We prove that branching-time temporal logics CTL and CT L ⁎ are polynomial-time embeddable into their single-variable fragments. It follows that satisfiability for CTL and CT L ⁎ , and therefore also for alternating-time temporal logics ATL and ATL ⁎ , in languages with one propositional variable is as algorithmically hard as satisfiability for the full logic: EXPTIME-complete for CTL and ATL , and 2EXPTIME-complete for CT L ⁎ and ATL ⁎. We discuss applicability of the technique used in the proofs to other modal and temporal logics, including propositional dynamic, epistemic, and temporal-epistemic logics, as well as many-dimensional and first-order modal and temporal logics. [ABSTRACT FROM AUTHOR]

We provide a behavioural logic for configuration structures, a model due to van Glabbeek and Plotkin which generalises the families of (finite) configurations of event structures. The logic is a conservative extension of a logic provided by Baldan and Crafa for prime event structures. We show that logical equivalence can be characterized as a form of hereditary history preserving bisimilarity. We compare such a notion of bisimilarity with an equivalence proposed by van Glabbeek in the setting of higher-dimensional automata, showing that, in general, it is finer, while the two notions coincide in the framework of general event structures. Finally, we explore how to restrict the general logic to capture a notion of history preserving bisimilarity. [ABSTRACT FROM AUTHOR]

• We study the logical and extensional representations of feature models. • We study the logical and extensional representations of attributed feature models. • We investigate the algebraic properties of operations and relations on the extensional representations of both models. • We identify the logical counterpart of the above relations and operations for both basic and attributed feature models. • We show that these operations and relations have meaning in lattices. Software-intensive systems can have thousands of interdependent configuration options across different subsystems. Feature models (FMs) allow designers to organize the configuration space by describing configuration options using interdependent features: a feature is a name representing some functionality and each software variant is identified by a set of features. Attributed feature models (AFMs) extend FMs to describe the, possibly constrained, choice of a value from domains such as integers or strings: each attribute is associated to one feature, and when the feature is selected then the attribute brings some additional information relative to the selected features. Different representations of FMs and AFMs have been proposed in the literature. In this paper we focus on the logical representation (which works well in practice) and the extensional representation (which has been recently shown well suited for theoretical investigations). We provide an algebraic and a logical characterization of operations and relations on FMs and AFMs, and we formalize the connection between the two characterizations as monomorphisms from lattices of logical FMs and AFMs to lattices of extensional FMs and AFMs, respectively. This formalization sheds new light on the correspondence between the algebraic and logical characterizations of operations and relations for FMs and AFMs. It aims to foster the development of a formal framework for supporting practical exploitation of future theoretical developments on FMs, AFMs and multi software product lines. [ABSTRACT FROM AUTHOR]

• We connect two different fields: differential program semantics and incremental computing. • Program distance is increasingly important for software analysis. • Differential logical relations are a new technique that measures the distance between programs as a third program. • Program derivates are used as a way to achieve incremental computation in higher-order languages. • Program derivates are canonical self-distances and differential logical relations can be used in incremental computing. We study the deep relation existing between differential logical relations and incremental computing by showing how self-differences in the former precisely correspond to derivatives in the latter. The byproduct of such a relationship is twofold: on the one hand, we show how differential logical relations can be seen as a powerful meta-theoretical tool in the analysis of incremental computations, enabling an easy proof of soundness of differentiation. On the other hand, we generalize differential logical relations so as to be able to interpret full recursion, something not possible in the original system. [ABSTRACT FROM AUTHOR]

In the area of Natural Computing, Reaction Systems (RSs) are a qualitative abstraction inspired by the functioning of living cells, suitable to model the main mechanisms of biochemical reactions. RSs interact with a context, and pose challenges for modularity, compositionality, extendibility and behavioural equivalence. In this paper we define a modular encoding of RSs as processes in the chained Core Network Algebra (cCNA), which is a new variant of the link-calculus. The encoding represents the behaviour of each entity separately and preserves faithfully their features, and we prove its correctness and completeness. Our encoding provides a Labelled Transition System (LTS) semantics for RSs. Based on the LTS semantics, we adapt the classical notion of bisimulation to define a novel equivalence, called bio-similarity, for studying properties of RSs. In particular, we define a new assertion language based on regular expressions, which allows us to specify the properties of interest, and use it to extend Hennessy-Milner logic to our setting. We prove that our bio-similarity relation and the logical equivalence, that are defined parametrically on some assertion of interest, coincide. Finally, we claim that our encoding contributes to increase the expressiveness of RSs, by exploiting the interaction among different RSs. [ABSTRACT FROM AUTHOR]

System I is a proof language for a fragment of propositional logic where isomorphic propositions, such as A ∧ B and B ∧ A , or A ⇒ (B ∧ C) and (A ⇒ B) ∧ (A ⇒ C) are made equal. System I enjoys the strong normalization property. This is sufficient to prove the existence of empty types, but not to prove the introduction property (every closed term in normal form is an introduction). Moreover, a severe restriction had to be made on the types of the variables in order to obtain the existence of empty types. We show here that adding η -expansion rules to System I permits to drop this restriction, and yields a strongly normalizing calculus which enjoys the full introduction property. [ABSTRACT FROM AUTHOR]

A logical theory for interface specification and verification of distributed, concurrent, interactive, real-time systems is worked out based on a semantic foundation including operational and denotational semantics. It supports a calculus for the specification and verification of concurrent interactive systems by interface assertions. Systems are composed acting concurrently and interacting via streams exchanged over their channels forming feedback loops. A denotational semantics is defined handling feedback communication by recursion and fixpoints based on strong causality and realizability instead of monotonicity. The resulting verification calculus for the specification logic is proved to be sound and relatively complete with respect to an operational semantics in terms of generalized Moore machines. Actually, two models of concurrent systems are defined, a more abstract one with communication and interaction modeled by untimed streams and a more concrete one working with timed streams. The untimed model is an abstraction of the timed model. The timed model allows expressing the laws of causality and realizability. Moreover, the timed model can be used to specify real-time properties. [ABSTRACT FROM AUTHOR]

Some extensions of ω -regular languages have been proposed in the literature to express asymptotic properties of ω -words which are not captured by ω -regular languages. They include ωB -regular languages, that extend ω -regular languages with boundedness, ωS -regular languages, that enrich ω -regular ones with strong unboundedness, ωBS -regular languages, that combine ωB - and ωS -regular ones, and ωT -regular languages, that include meaningful languages which are not ωBS -regular. Formal definitions of extended ω -regular languages have been given in terms of both suitable classes of automata and extended ω -regular expressions, while satisfactory temporal logic counterparts are still missing. In this paper, we give a characterization of them in terms of interval temporal logics by providing an explicit encoding of expressions into formulas. [ABSTRACT FROM AUTHOR]

Non-deterministic constraint logic (NCL) is a simple model of computation based on orientations of a constraint graph with edge weights and vertex demands. NCL captures PSPACE and has been a useful tool for proving algorithmic hardness of many puzzles, games, and reconfiguration problems. In particular, its usefulness stems from the fact that it remains PSPACE -complete even under severe restrictions of the weights (e.g., only edge-weights one and two are needed) and the structure of the constraint graph (e.g., planar and/or graphs of bounded bandwidth). While such restrictions on the structure of constraint graphs do not seem to limit the expressiveness of NCL , the building blocks of the constraint graphs cannot be limited without losing expressiveness: We consider as parameters the number of weight-one edges and the number of weight-two edges of a constraint graph, as well as the number of and or or vertices of an and/or constraint graph. We show that NCL is fixed-parameter tractable (FPT) for any of these parameters. In particular, for NCL parameterized by the number of weight-one edges or the number of and vertices, we obtain a linear kernel. It follows that, in a sense, NCL as introduced by Hearn and Demaine is defined in the most economical way for the purpose of capturing PSPACE. [ABSTRACT FROM AUTHOR]

Unified Temporal Logic (UTL) combines all characteristics of traditional Linear Temporal Logic (LTL) and Propositional Projection Temporal Logic (PPTL). It can be used to describe full regular and omega-regular properties, which are often encountered in the field of formal verification. To support formal verification with UTL, this paper proposes a proof system for UTL. First, the syntax and semantics of UTL are briefly introduced. Further, axioms and inference rules are formalized. Besides, a number of theorems are derived and proved to refine the system. Moreover, the soundness and completeness of the proof system are proved in detail. To facilitate the completeness proof, some auxiliary lemmas are introduced and proved in advance. Finally, an example is given to illustrate how to use this proof system for verifying properties of a system. [ABSTRACT FROM AUTHOR]

Gödel's Dialectica interpretation was conceived as a tool to obtain the consistency of Heyting arithmetic in the 40s. In recent years, several proof theoretic transformations, based on Gödel's Dialectica interpretation, have been used systematically to extract new content from classical proofs, following a suggestion of Kreisel. Thus, the interpretation has found new relevant applications in several areas of mathematics and computer science. Several authors have explained the Dialectica interpretation in categorical terms. In particular, de Paiva introduced the notion of a Dialectica category as an internal version of Gödel's Dialectica Interpretation in her doctoral work. This was generalised by Hyland and Hofstra, who considered the interpretation in terms of fibrations. In our previous work, we introduced an intrinsic presentation of the Dialectica construction via a generalisation of Hofstra's work, using the notion of Gödel fibration and its proof-irrelevant version, a Gödel doctrine. The key idea is that Gödel fibrations (and doctrines) can be thought of as fibrations generated by some basic predicates playing the role of quantifier-free predicates. This categorification of quantifier-free predicates is crucial not only to show that our notion of Gödel fibration is equivalent to Hofstra's Dialectica fibration in the appropriate way, but also to show how Gödel doctrines embody the main logical features of the Dialectica Interpretation. To show that, we derive the soundness of the interpretation of the implication connective, as expounded by Troelstra, in the categorical model. This requires extra logical principles, going beyond intuitionistic logic, namely (suitable versions of) the Markov Principle (MP) and the Independence of Premise (IP) principle, as well as some choice. We show how these principles are satisfied in the categorical setting, establishing a tight correspondence between the logical system and the categorical framework. This tight correspondence should come in handy not only when discussing the traditional applications of Dialectica, but also when dealing with some newer uses of the interpretation, as in modelling games or concurrency theory. Finally, to complete our analysis, we characterise categories obtained as a result of the Hyland, Johnstone and Pitts tripos-to-topos construction when applied to Gödel doctrines. [ABSTRACT FROM AUTHOR]