Computation Tree Logic Research Articles

Incremental model checking for fuzzy computation tree logic

Fuzzy model checking, also called multi-valued model checking, has proved to be an effective technique in verifying properties of fuzzy systems. One important issue with fuzzy model checking, is that a model adopted in fuzzy model checking is frequently updated with small changes, and it is too costly to run a model-checking algorithm from scratch in response to every update. To address the issue, in this paper, we consider the incremental model-checking approach for fuzzy systems by making maximal use of previous model checking results or in other words, by minimizing unnecessary recomputation. The models of our study are fuzzy Kripke structures, which are a fuzzy counterpart of Kripke structures and used to describe fuzzy systems, while the properties of fuzzy systems are expressed using fuzzy computation tree logic, a fuzzy temporal logic derived from computation tree logic. The focus of the paper is on how to design incremental model-checking algorithms for two until-formulas which characterize the maximal or dually minimum constrained reachability properties with respect to fuzzy Kripke structures under transition insertions or deletions but not both. The feasibility of our approach is illustrated by an example arising from the path planning problem of mobile robots.

Model Checking Computation Tree Logic Over Multi-Valued Decision Processes and Its Reduction Techniques

Model Checking Computation Tree Logic Over Multi-Valued Decision Processes and Its Reduction Techniques

Verifying chip designs at RTL level

As chip designs become increasingly complex, the potential for errors and defects in circuits inevitably rises, posing significant challenges to chip security and reliability. This study investigates the use of the SAT-based bounded model checking (BMC) for Propositional Projection Temporal Logic (PPTL) to verify Verilog chip designs at the register transfer level (RTL). To this end, we propose an algorithm to implement automated extraction of state transfer relations from AIGER netlist and construction of Kripke structure. Additionally, we employ PPTL with the full regular expressiveness to describe the circuit properties to be verified, especially the periodic repetitive properties. This is not possible with Linear Temporal Logic (LTL) and Computational Tree Logic (CTL). By combining the PPTL properties with finite system paths and transforming them into conjunctive normal forms (CNFs), we utilize an SAT solver for verification. Experimental results demonstrate that our verification tool, SAT-BMC4PPTL, achieves higher verification efficiency and comprehensiveness.

Generalized possibility computation tree logic with frequency and its model checking

In recent years, there has been significant research in the field of possibilistic temporal logic. However, existing works have not yet addressed the issue of frequency, which is a common form of uncertainty in the real world. This article aims to fill this gap by incorporating frequency information into possibilistic temporal logic and focusing on the model-checking problem of generalized possibility computation tree logic (GPoCTL) with frequency information. Specifically, we introduce generalized possibility computation tree logic with frequency (GPoCTLF). Although its syntax can be considered as an extension of frequency constraints of the always operator (□) in GPoCTL, they are fundamentally different in semantics and model-checking methods. To facilitate this extension, useful frequency words such as “always”, “usually”, “often”, “sometimes”, “occasionally”, “rarely”, “hardly ever” and “never” are defined as fuzzy frequency operators in this article. Therefore, this article focuses on investigating the model-checking problem of the frequency-constrained always operator. In addition, we analyze the relationship between some GPoCTLF path formulas and GPoCTL path formulas. Then, we provide a model-checking algorithm for GPoCTLF and analyze its time complexity. Finally, an example of a social network is used to illustrate the calculation process of the proposed method and its potential applications.

Multi-valued verification of commitment systems with uncertainty and inconsistency in multi-source data settings

In the dynamic landscape of Internet of Things (IoT) applications within multi-source data environments, ensuring the reliability and correctness of system communications has become a paramount concern. This is particularly evident in the presence of commitment protocols with inconsistency and uncertainty. This paper tackles these challenges by introducing a new logic, termed Six-Values Computation Tree Logic for Commitment (6V-CTLC), specifically crafted to adeptly model IoT systems with both inconsistency and uncertainty. Employing this logic, we devise an innovative reduction-based multi-valued model checking approach to verify the systems under scrutiny. Our method is implemented through a Java transformation tool we developed to translate the 6V-CTLC logic to the classical logic of commitment (CTLC) and seamlessly interfaces with the efficient model checker MCMAS+. Applying this approach, we verify an abstracted 6V-CTLC model featuring uncertainty and inconsistency, as well as the original model of our system before abstraction. Furthermore, we assess the scalability of our approach through ten experiments, comparing the results obtained from verifying the two models. The findings demonstrate the effectiveness of system abstraction in mitigating the state explosion problem, while the developed multi-valued model checking technique yields precise results.

Temporal logics for compartmental models

Abstract This paper introduces two logic frameworks for the study of SIR (Susceptible-Infected-Recovered) and SIRS compartmental epidemic models, one based on Linear Temporal Logic and the other on Computation Tree Logic. We provide a short literature overview on compartmental models and other related works using logics, and then define our logics with their respective axiomatizations, and demonstrate their soundness and completeness proofs.

Generalized Formal Model-Verifier: A Formal Approach for Verifying Static Models

The field of software modeling has gained significant popularity in the last decades. By capturing the static aspects of the software requirements, model-driven engineering eases the development and maintenance of software. However, additional constraints, such as invariants on model elements, that the solution must conform to may be too complex to include in the structure of the model itself. External solutions are often used to describe static constraints on models, the most prevalent approach being the Object Constraint Language (OCL) and its formal variants. This paper proposes the Generalized Formal Model-Verifier (GFMV), which is a general approach for verifying static constraints on software models. GFMV employs different formal verification methods based on Kripke Structures. Kripke Structures are used to capture the static structure of the model, then the constraints are formalized using a first-order branching-time logic, the Computational Tree Logic (CTL). Finally, the NuSMV model checker is reused to verify whether the constraints formalized in CTL hold on the formal Kripke Structure. When compared to existing solutions, GFMV offers increased generality and formal proof that the constraints hold on the model. The expressive power and runtime-scalability of the approach are evaluated on a real-world example model and OCL invariants cited from literature.

Model checking timed recursive CTL

We introduce Timed Recursive CTL, a merger of two extensions of the well-known branching-time logic CTL: Timed CTL is interpreted over real-time systems like timed automata; Recursive CTL introduces a powerful recursion operator which takes the expressiveness of this logic CTL well beyond that of regular properties. The result is an expressive logic for real-time properties. We show that its model checking problem is decidable over timed automata, namely 2-EXPTIME-complete.

Model checking fuzzy computation tree logic of multi-agent systems based on fuzzy interpreted systems

Effective communication among autonomous agents is crucial for coordination and solving complex tasks within multi-agent systems. To formalize interactions between agents, social accessibility relations are often utilized. Current research employs model checking algorithms to verificate social commitment properties in multi-agent systems. In fuzzy multi-agent systems, direct quantification and computation of commitment attributes pose challenges. This paper introduces an indirect fuzzy model checking algorithm designed to convert social commitments in uncertain scenarios into quantifiable attributes for verification. Firstly, we propose a fuzzy communicative interpreted system model to represent multi-agent systems with uncertain communication. We then improve fuzzy computation tree logic by adding modalities for commitments and fulfillment, resulting in a fuzzy computation tree logic with commitments for describing system properties related to commitments. A fuzzy model checking algorithm is subsequently presented. This algorithm converts the task of model checking fuzzy computation tree logic with commitments based on fuzzy interpreted systems into model checking fuzzy computation tree logic based on fuzzy Kripke structures. We conclude by providing proofs of correctness and complexity analysis of our algorithm. Furthermore, we demonstrate the effectiveness of our approach for model checking social commitments under fuzzy conditions through simulation experiments on an online shopping system.

Submodel Enumeration for CTL Is Hard

Expressing system specifications using Computation Tree Logic (CTL) formulas, formalising programs using Kripke structures, and then model checking the system is an established workflow in program verification and has wide applications in AI. In this paper, we consider the task of model enumeration, which asks for a uniform stream of output systems that satisfy the given specification. We show that, given a CTL formula and a system (potentially falsified by the formula), enumerating satisfying submodels is always hard for CTL--regardless of which subset of CTL-operators is considered. As a silver lining on the horizon, we present fragments via restrictions on the allowed Boolean functions that still allow for fast enumeration.

Robust computation tree logic

AbstractIt is widely accepted that every system should be robust in that “small” violations of environment assumptions should lead to “small” violations of system guarantees, but it is less clear how to make this intuition mathematically precise. While significant efforts have been devoted to providing notions of robustness for linear temporal logic, branching-time logics, such as computation tree logic (CTL) and CTL*, have received less attention in this regard. To address this shortcoming, we develop “robust” extensions of CTL and CTL*, which we name robust CTL (rCTL) and robust CTL* (rCTL*). Both extensions are syntactically similar to their parent logics but employ multi-valued semantics to distinguish between “large” and “small” violations of the specification. We show that the multi-valued semantics of rCTL make it more expressive than CTL, while rCTL* is as expressive as CTL*. Moreover, we show that the model checking problem, the satisfiability problem, and the synthesis problem for rCTL and rCTL* have the same asymptotic complexity as their non-robust counterparts, implying that robustness can be added to branching-time logics for free.

Lazy model checking for recursive state machines

Recursive state machines (RSMs) are state-based models for procedural programs with wide-ranging applications in program verification and interprocedural analysis. Model-checking algorithms for RSMs and related formalisms have been intensively studied in the literature. In this article, we devise a new model-checking algorithm for RSMs and requirements in computation tree logic (CTL) that exploits the compositional structure of RSMs by ternary model checking in combination with a lazy evaluation scheme. Specifically, a procedural component is only analyzed in those cases in which it might influence the satisfaction of the CTL requirement. We implemented our model-checking algorithms and evaluate them on randomized scalability benchmarks and on an interprocedural data-flow analysis of Java programs, showing both practical applicability and significant speedups in comparison to state-of-the-art model-checking tools for procedural programs.

Probabilistic Model Checking GitHub Repositories for Software Project Analysis

GitHub serves as a platform for collaborative software development, where contributors engage, evolve projects, and shape the community. This study presents a novel approach to analyzing GitHub activity that departs from traditional methods. Using Discrete-Time Markov Chains and probabilistic Computation Tree Logic for model checking, we aim to uncover temporal dynamics, probabilities, and key factors influencing project behavior. By explicitly modeling state transitions, our approach provides transparency and explainability for sequential properties. The application of our method to five repositories demonstrates its feasibility and scalability and provides insights into the long-term probabilities of various activities. In particular, the analysis provides valuable perspectives for project managers to optimize team dynamics and resource allocation. The query specifications developed for model checking allow users to generate and execute queries for specific aspects, demonstrating scalability beyond the queries we present. In conclusion, our analysis provides an understanding of GitHub repository properties, branch management, and subscriber behavior. We anticipate its applicability to various open-source projects, revealing trends among contributors based on the unique characteristics of repositories.

MV-Checker: A software tool for multi-valued model checking intelligent applications with trust and commitment

Intelligent applications are highly susceptible to uncertainty and inconsistency due to the intense and intricate interactions among their autonomous components (or agents), making their verification theoretically and practically challenging. This paper presents the design and implementation of a new open-source and scalable software tool for modeling and verifying intelligent applications with commitment and trust protocols under both uncertainty and inconsistency settings, using reduction-based multi-valued model checking techniques. The proposed tool is equipped with original and novel algorithms that transform our logics of multi-valued commitment (mv-CTLC) and multi-value trust (mv-TCTL) that we recently introduced to their classical two-valued commitment (CTLC) and trust (TCTL) logic versions as well as to Computational Tree Logic (CTL). Moreover, the tool transforms the mv-CTL to CTL, and it is applicable for the classical model checking by transforming the classical logics of trust and commitment to CTL. To demonstrate the practicality and applicability of the proposed tool in real settings, we present and report experimental results over two blockchain-based applications in the healthcare domain. Finally, we provide discussions and comparisons between the proposed approaches regarding scalability and efficiency. Moreover, we provide packages of more than 11 experiments, including the ones we conduct in this paper and enhanced experiments from previous works. Our findings ensure that the proposed approaches and the software tool that implements them are highly efficient and scalable, giving accurate results under varying conditions.

D3NN: Data-Driven Dual-level Neural Network Tool for Dynamical System Modeling and Abstraction

This paper presents D3NN, a neural network learning tool for dual-level dynamic system modeling. This tool aims to model the dynamic system under a dual-level modeling framework, i.e., modeling the system dynamics through a computationally efficient and precise low-level neural hybrid system and an interpretable high-level transition system abstraction. Given samples of the dynamic system and user specifications, the proposed tool can generate a low-level distributive learning framework consisting of shallow neural network approximations for local dynamics and its high-level transition system abstraction that allows Computational Tree Logic (CTL) formulae verification.

Реляционная версия многоагентной логики деревьев вычислений $\mathcal{CTLK}$

This paper deals with multi-agent computation tree logic --- $\mathcal{CTLK}$ (Computation Tree Logic with Knowledge). Each agent represents its own computational route of the initial problem, and new branches of possible computational routes spawn new agents. The logic $\mathcal{CTLK}$ is a natural enrichment of $\mathcal{CTL}$ by new knowledge operators. We introduce alternative to automata Kripke's relational semantics, describes properties of $\mathcal{CTLK}^{Rel}$-frame and proves finite approximability.

Model checking combined trust and commitments in Multi-Agent Systems

Trust and social commitments have been studied with different objectives for communication in Multi-Agent Systems (MASs) separately. The purpose of this paper is to present the first logical framework to explore the relationship between two key concepts in autonomous MASs, namely trust and commitments among agents, along with its model checking algorithms. An analysis is performed on this relationship, with a specific emphasis on the perspectives of semantics and model checking. The analysis is carried out within the framework of Trust Computation Tree Logic with Commitments (CTLC) logic, an extended logic built on top of the standard branching temporal Computation Tree Logic (CTL) by including modalities for reasoning about commitments and their fulfillment. Moreover, the study employs a trust operator to facilitate trust reasoning. We propose thus Trust Computation Tree Logic with Commitments (TCTLC), a new logic able to express properties about trust and commitments simultaneously. Such rich properties cannot be expressed in other languages. We introduce the semantics using the extended formalism of interpreted systems. We propose some postulates and proofs that show how we can reason about combined trust and commitments in the logic proposed. New Binary Decision Diagram (BDD)-based algorithms for our logic are presented and implemented as additional libraries of the Model Checker for Multi-Agent Systems (MCMAS), the default model checker of MASs. Furthermore, we prove that although TCTLC extends CTL, its model checking algorithm remains polynomial (P-complete) with respect to the size of the model and the length of the formula. Similarly, the space complexity for concurrent programs also remains unchanged, which is polynomial (PSPACE-complete) with respect to the size of the components within these programs. Finally, to evaluate the proposed technique, we report the experimental results using an industrial case study and compare the results with those obtained on relevant benchmarks.

Bounded model checking for interval probabilistic timed graph transformation systems against properties of probabilistic metric temporal graph logic

Cyber-physical systems often encompass complex concurrent behavior with timing constraints and probabilistic failures on demand. The analysis whether such systems with probabilistic timed behavior adhere to a given specification is essential. The formalism of Interval Probabilistic Timed Graph Transformation Systems (IPTGTSs) is often a suitable choice to model cyber-physical systems because (a) its rule-based approach to graph transformation can capture a wide range of system's structure dynamics when the states of the system can be represented by graphs while (b) it employs interval specifications for probabilistic behavior as well as lower and upper bounds on delays of steps to support systems where precise probabilities and delays are not known or may change during the runtime of the system. Probabilistic Metric Temporal Graph Logic (PMTGL) has been introduced as a powerful specification language to express worst-case/best-case probabilistic timed requirements such as actor-based soft deadlines using (a) path properties relying on its Metric Temporal Graph Logic fragment to track individual graph elements and (b) an operator inherited from Probabilistic Timed Computation Tree Logic to express worst-case/best-case probabilistic requirements identifying worst-case/best-case resolutions of non-determinism. Bounded Model Checking (BMC) support for Probabilistic Timed Graph Transformation Systems (PTGTSs) w.r.t. properties specified using PMTGL has been already presented. However, for IPTGTSs no analysis support w.r.t. PMTGL properties has been developed for stating metric temporal properties on identified subgraphs and their structural changes over time.In this paper, we adapt the BMC approach developed for PTGTSs to the case of IPTGTSs extending modeling and analysis support to the usage of probability intervals more appropriately covering cyber-physical systems where probabilistic effects cannot be specified precisely and need to be approximated instead. In our evaluation, we apply an implementation of our BMC approach in AutoGraph to a novel running example demonstrating the effect of using probability intervals instead of precise probability values.

A Modeling and Verification Method of Cyber-Physical Systems Based on AADL and Process Algebra

Cyber-Physical Systems (CPS) are the next generation of intelligent systems that integrate information control devices with physical resources. With increasingly close connections between CPS components and frequent interactions, potential defects grow exponentially, rendering the operating environment of CPS unreliable. Therefore, research on methods and theories to ensure the correctness, safety and reliability of CPS is not only an important research topic but also an inevitable challenge. In this paper, we propose a CPS modeling and verification method based on Architecture Analysis & Design Language (AADL) and process algebra to address this challenge. Due to the continuous, time-constrained, stochastic, uncertain and concurrent characteristics of CPS, this paper considers both flexibility and rigor in the modeling process. We first extend the ability of AADL to describe the multiple characteristics of CPS and propose Hybrid Probability-AADL (HP-AADL). Second, this paper introduces conditional execution, conditional interruption and probability operators into Temporal Calculus of Communication Systems (TCCS) and designs a new formal modeling language Hybrid Probability-Temporal Calculus of Communication Systems (HP-TCCS). However, HP-AADL is a semi-formal modeling language that cannot be directly used for formal verification, it cannot strictly guarantee the quality of the established CPS models, including its functional correctness and safety. Therefore, this paper proposes transformation rules from HP-AADL to HP-TCCS, which enables model checking of CPS models described in HP-AADL within HP-TCCS. Additionally, this paper designs a new formal specification language HPAT-Spatial Temporal Logic (HPAT-STL) based on Probabilistic Computation Tree Logic (PCTL) and Spatial Logic, which characterizes the temporal, probabilistic and spatial properties of CPS model. To achieve formal verification of HP-TCCS model and HPAT-STL formulas, this paper proposes a model checking algorithm HPAT-Model Checking Algorithm (HPAT-MCA). Finally, we discuss a typical CPS example to demonstrate the effectiveness of our proposed method in ensuring correct, safe and reliable CPS.

Temporal logics with language parameters

We develop a generic framework to extend the logics LTL, CTL+ and CTL⁎ by automata-based connectives from formal language classes and analyse this framework with regard to regular languages, visibly pushdown languages, deterministic and non-deterministic context-free languages. More precisely, we consider how the use of different automata classes changes the expressive power of the logics and provide algorithms for the satisfiability and model checking problems induced by the use of different classes of automata. For the model checking problem, we treat not only finite Kripke transition systems, but also visibly pushdown systems and pushdown systems. We provide completeness or undecidability results in all cases and show that the extensions we consider can formulate properties not expressible in classical temporal logics or regular extensions thereof.