Temporal Logic

Obtaining accurate system models for verification is a hard and time consuming process, which is seen by industry as a hindrance to adopt otherwise powerful modeldriven development techniques and tools. In this paper we pursue an alternative approach where an accurate high-level model can be automatically constructed from observations of a given black-box embedded system. We adapt algorithms for learning finite probabilistic automata from observed system behaviors. We prove that in the limit of large sample sizes the learned model will be an accurate representation of the data-generating system. In particular, in the large sample limit, the learned model and the original system will define the same probabilities for linear temporal logic (LTL) properties. Thus, we can perform PLTL model-checking on the learned model to infer properties of the system. We perform experiments learning models from system observations at different levels of abstraction. The experimental results show the learned models provide very good approximations for relevant properties of the original system.

Diachronic uncertainty, uncertainty about where an agent falls in time, poses interesting conceptual difficulties. Although the agent is uncertain about where she falls in time, this uncertainty can only obtain at a particular moment in time. We resolve this conceptual tension by providing a transformation from models with diachronic uncertainty relations into “equivalent” models with only synchronic uncertainty relations. The

We introduce a logical verification methodology for checking behavioral properties of service-oriented computing systems. Service properties are described by means of SocL, a branching-time temporal logic that we have specifically designed for expressing in an effective way distinctive aspects of services, such as, acceptance of a request, provision of a response, correlation among service requests and responses, etc. Our approach allows service properties to be expressed in such a way that they can be independent of service domains and specifications. We show an instantiation of our general methodology that uses the formal language COWS to conveniently specify services and the expressly developed software tool CMC to assist the user in the task of verifying SocL formulas over service specifications. We demonstrate the feasibility and effectiveness of our methodology by means of the specification and analysis of a case study in the automotive domain.

The development of most large and complex systems necessarily involves many people+ach with their own perspectives on the system defined by their knowledge, responsibilities, and commitments. To address this we have advocated distributed development of specifications from multiple perspectives. However, this leads to problems of identifying and handling inconsistencies between such perspectives. Maintaining absolute consistency is not always possible. Often this is not even desirable since this can unnecessarily constrain the development process, and can lead to the loss of important information. Indeed since the real-world forces us to work with inconsistencies, we should formalize some of the usually informal or extra-logical ways of responding to them. This is not necessarily done by eradicating inconsistencies but rather by supplying logical rules specifying how we should act on them. To achieve this, we combine two lines of existing research: the Viewpoints framework for perspective development, interaction and organization, and a logic-based approach to inconsistency handling. This paper presents our technique for inconsistency handling in the Viewpoints framework hy using simple examples.

We first advocate that the AUML (Agent Unified Modeling Language) notation, even in its new version, is not precise enough to adequately describe protocols. This problem was long identified by Harel and we propose to follow his solution: extend sequence diagrams with a ...

This paper presents ArchiTRIO (Architectural TRIO), a new temporal logic language which combines a subset of the UML notation with a precise formal semantics inspired from the authors’ experiences. ArchiTRIO allows developers to use standard UML 2.0 notation to describe non-critical aspects of systems, but it also offers a complementary formal notation, fully integrated with the UML one, to represent those system aspects that require precise modeling.

In this paper we study a version of constructive linear-time temporal logic (LTL) with the "next" temporal operator. The logic is originally due to Davies, who has shown that the proof system of the logic corresponds to a type system for binding-time analysis via the Curry-Howard isomorphism. However, he did not investigate the logic itself in detail; he has proved only that the logic augmented with negation and classical reasoning is equivalent to (the "next" fragment of) the standard formulation of classical lineartime temporal logic. We give natural deduction, sequent calculus and Hilbert-style proof systems for constructive LTL with conjunction, disjunction and falsehood, and show that the sequent calculus enjoys cut elimination. Moreover, we also consider Kripke semantics and prove soundness and completeness. One distinguishing feature of this logic is that distributivity of the "next" operator over disjunction " (A ∨ B) ⊃ A ∨ B" is rejected in view of a type-theoretic interpretation.

A temporal-constraint logic programming framework for the specification and automatic verification and synthesis of assembly sequences is developed. The implemented tool is based on the formulated and derived precedence properties for a general mechanical assembly. This tool, called the Mechanical Assembly Sequence Satisfiability Checker (MASS-C), supports the use of a subset of temporal logic for assembly constraint specification. MASS-C provides the logic programming framework by which the designer can be relieved of the tedium of finding the assembly sequences, and the assembly sequence planning process manifests itself in the implicit modelling of assembly sequences by acquiring and formulating the set of correct and complete assembly constraints as a logic program. MASS-C implements a class of temporal expressions as predicates for logic programming of assembly constraints. It provides facilities to either verify an assembly sequence or synthesise all assembly sequences that satisfy the specified constraints composed as a logic program. Two examples illustrate the use of MASS-C for such verification and synthesis.

Online virtual worlds such as Second Life provide a rich medium for unstructured human interaction in a shared simulated 3D environment. However, many human interactions take place in a structured social context where participants are subject to expectations governing their behaviour, and current virtual worlds do not provide any support for this type of interaction. There is therefore an opportunity to adapt the tools developed in the multi-agent systems community for structured social interactions between software agents (inspired by human society) and adapt these for use with the computer-mediated human communication provided by virtual worlds. This paper describes the integration of one such tool with Second Life. A model checker for monitoring social expectations defined in temporal logic has been integrated with Second Life, allowing users to be notified when their expectations of others have been fulfilled or violated.

We propose a data model for representing moving objects in database systems. It is called the Moving Objects Spatio-Temporal (MOST) data model. We also propose Future Temporal Logic (FTL) as the query language for the MOST model, and devise an algorithm for processing FTL queries in MOST

In this paper, we consider the robust interpretation of Metric Temporal Logic (MTL) formulas over signals that take values in metric spaces. For such signals, which are generated by systems whose states are equipped with non-trivial metrics, for example continuous or hybrid, robustness is not only natural, but also a critical measure of system performance. Thus, we propose multi-valued semantics for MTL formulas, which capture not only the usual Boolean satisfiability of the formula, but also topological information regarding the distance, ε, from unsatisfiability. We prove that any other signal that remains ε-close to the initial one also satisfies the same MTL specification under the usual Boolean semantics. Finally, our framework is applied to the problem of testing formulas of two fragments of MTL, namely Metric Interval Temporal Logic (MITL) and closed Metric Temporal Logic (clMTL), over continuous-time signals using only discrete-time analysis. The motivating idea behind our approach is that if the continuous-time signal fulfills certain conditions and the discrete-time signal robustly satisfies the temporal logic specification, then the corresponding continuous-time signal should also satisfy the same temporal logic specification.

The aim of the paper is to present a sound, strongly complete and decidable probabilistic temporal logic that can model reasoning about evidence. The formal system developed here is actually a solution of a problem proposed by Halpern and Pucella (J Artif Intell Res 26: 2006).

Most existing natural language database interfaces (NLDBs) were designed to be used with database systems that provide very limited facilities for manipulating time-dependent data, and they do not support adequately temporal linguistic mechanisms (verb tenses, temporal adverbials, temporal subordinate clauses, etc.). The database community is becoming increasingly interested in temporal database systems, that are intended to store and manipulate in a principled manner information not only about the present, but also about the past and future. When interfacing to temporal databases, supporting temporal linguistic mechanisms becomes crucial. We present a framework for constructing natural language interfaces for temporal databases (NLTDBs), that draws on research in tense and aspect theories, temporal logics, and temporal databases. The framework consists of a temporal intermediate representation language, called TOP, an HPSG grammar that maps a wide range of questions involving temporal mechanisms to appropriate TOP expressions, and a provably correct method for translating from TOP to TSQL2, TSQL2 being a recently proposed temporal extension of the SQL database language. This framework was employed to implement a prototype NLTDB using ALE and Prolog.

This paper presents a new logic of operation for time overcurrent relays. With the application of the proposed technique, the sensitivity of time overcurrent relays is increased. In order to obtain this, the relay operates with a dynamic pickup setting, such as load current. Additionally, fast operation of overcurrent relays is obtained. The functional structure is described and the logic

Research with autonomous unmanned aircraft systems is reaching a new degree of sophistication where targeted missions require complex types of deliberative capability integrated in a practical manner in such systems. Due to these pragmatic constraints, integration is just as important as theoretical and applied work in developing the actual deliberative functionalities. In this article, we present a temporal logic-based task planning and execution monitoring framework and its integration into a fully deployed rotor-based unmanned aircraft system developed in our laboratory. We use a very challenging emergency services application involving body identification and supply delivery as a vehicle for showing the potential use of such a framework in real-world applications. TALplanner, a temporal logic-based task planner, is used to generate mission plans. Building further on the use of TAL (Temporal Action Logic), we show how knowledge gathered from the appropriate sensors during plan execution can be used to create state structures, incrementally building a partial logical model representing the actual development of the system and its environment over time. We then show how formulas in the same logic can be used to specify the desired behavior of the system and its environment and how violations of such formulas can be detected in a timely manner in an execution monitor subsystem. The pervasive use of logic throughout the higher level deliberative layers of the system architecture provides a solid shared declarative semantics that facilitates the transfer of knowledge between different modules.

The development process of complex systems needs to take in account differents domains and aspects. SysML (Systems Modeling Language) is a new modeling language that allows a system description with various integrated diagrams (as structure, behavior and requirements diagrams), but SysML lacks formality for the requirement verification. The aim of this paper is to propose an approach to verify complex systems using SysML as a language which describes the system structure and requirements. Petri nets and temporal logic LTL are used respectively to formalize the system behavior and requirements. The benefit of such formalization is to allow an automatic formal verification. In order to demonstrate this methodology, it will be used a factory automation system, modeled by SysML and Petri nets, and verified by the TINA toolbox.

This thesis describes the theoretical and practical foundations of a system for the static analysis of XML processing languages. The system relies on a fixpoint temporal logic with converse, derived from the µ-calculus, where models are finite trees. This calculus is expressive enough to capture regular tree types along with multi-directional navigation in trees, while having a single exponential time complexity. Specifically the decidability of the logic is proved in time 2 O(n) where n is the size of the input formula.

When a group of authors collaboratively edits interrelated documents, consistency problems occur almost immediately. Current document management systems (DMS) provide useful mechanisms such as document locking and version control, but often lack consistency management facilities. If at all, consistency is "defined" via informal guidelines, which do not support automatic consistency checks.

This paper addresses the formal verification of diagnosis systems. Given a physical system and a diagnosis system that observes it, we tackle the problem of verifying that the diagnosis system will be able to recognize the situations that it is required to recognize. In our approach, the physical system is formally modeled as a Kripke structure, while diagnosability is checked by looking for pairs of scenarios that (1) are indistinguishable based on the observable part of the system but (2) lead to situations that are required to be distinguished. We focus on the practical applicability of the method: diagnosability is recast in terms of a model checking problem, and allows for the direct use of state-of-the-art symbolic model checking techniques.

Nested words are a structured model of execution paths in procedural programs, reflecting their call and return nesting structure. Finite nested words also capture the structure of parse trees and other tree-structured data, such as XML. We provide new temporal logics for finite and infinite nested words, which are natural extensions of LTL, and prove that these logics are first-order expressively-complete. One of them is based on adding a "within" modality, evaluating a formula on a subword, to a logic CaRet previously studied in the context of verifying properties of recursive state machines (RSMs). The other logic, NWTL, is based on the notion of a summary path that uses both the linear and nesting structures. For NWTL we show that satisfiability is EXPTIME-complete, and that model-checking can be done in time polynomial in the size of the RSM model and exponential in the size of the NWTL formula (and is also EXPTIME-complete). Finally, we prove that first-order logic over nested words has the three-variable property, and we present a temporal logic for nested words which is complete for the two-variable fragment of first-order.

In the conventional supervisory control framework for discrete event systems with partial event observation, it is assumed that, for each event, the corresponding output symbol is determined deterministically. However, this assumption does not hold in discrete event systems such as a system with sensor errors and a mobile system, where an output symbol depends on not only an event but also a state at which the event occurs. In this paper, we model such a discrete event system by a Mealy automaton with a nondeterministic output function. We consider two kinds of supervisors: one assigns its control action based on a permissive policy and the other based on an antipermissive one. We present necessary and sufficient conditions for each of them to achieve a given specification. We then present algorithms for verifying these conditions. Moreover, we discuss the relationship between the two supervisors in the case that an output function is deterministic.

Utility Computing (UC) is concerned with the provisioning of computational resources (compute-power, storage, network bandwidth), on a per-need basis, to corporate businesses. Service-level Agreements (SLAs)contracts between a provider and a customer -are a sine qua non in the deployment of UC. A crucial stage in the life-cycle of contracts (such as SLAs) is their automated performance monitoring while active; a significant aspect of which concerns the tracking of contract state. In this work, we define an ontology to capture aspects of SLAs that are pertinent to the tracking of state for performance monitoring, and generalise these aspects so that the ontology may be applicable to other contract domains. The ontology is formalised as an XML-based language, called CTXML (contract tracking XML). The semantics for CTXML are presented in terms of a computational model based on the Event Calculus.

This book is the second volume in a series of volumes on temporal logics. While Volume 1, which was published in 1994, considered the basic concepts and methods of temporal logics, this volume "deals with some aspects of their applications." It contains 18 chapters of varying length, ranging from the only 15 pages long Chapter 15 on the METATEM programming language to the 97 pages long Chapter 18 on Calendar logic, covering a wide range of topics from automata theoretic approaches to the satisfiability problem in monadic second order logic to two-dimensional temporal logics.

This paper describes the language LUSTRE which is a data flow synchronous language, designed for programming reactive systems-uch as automatic control and monitoring s y s t e m s a s well as for describing hardware. The data flow aspect of LUSTRE makes it very close to usual description tools in these domains (blockdiagrams, networks of operators, dynamical sample-systems, etc.), and its synchronous interpretation makes it well suited for handling time in programs. Moreover, this synchronous interpretation allows it to be compiled into an efficient sequential program. Finally, the LUSTRE formalism is very similar to temporal logics. This allows the language to be used for both writing programs and expressing program properties, which results in an original program verification methodology. 0 1991 IEEE 1305 __ HALBWACHS et al., SYNCHRONOUS DATAFLOW PROGRAMMING LANGUAGE LUSTRE 1311 ~-_ _ _~ ~ ~~

Source Control Repositories are used in most software projects to store revisions to source code files. These repositories operate at the file level and support multiple users. A generalized formal model of source control repositories is described herein. The model is a graph in which the different entities stored in the repository become vertices and their relationships become edges. We then define SCQL, a first order, and temporal logic based query language for source control repositories. We demonstrate how SCQL can be used to specify some questions and then evaluate them using the source control repositories of five different large software projects.

In some contexts, especially in safety or security critical applications, it may be crucial to verify that the interactive behaviour of these systems possess certain formally expressed properties. Our project is to describe the interactive behaviour of a system by building an abstract formal model of it and to verify automatically that this behaviour possesses the required properties. In this paper, we suggest to use data flows for this purpose. We use the formal language Lustre to denote such flows. This language permits to express safety temporal properties and to build some syntactical structures in order to verify and test them by using appropriate tools.

A business process is the combination of a set of activities with logical order and dependence, whose objective is to produce a desired goal. Business process modeling (BPM) using knowledge of the available process modeling techniques enables a common understanding and analysis of a business process. Industry and academics use informal and formal techniques respectively to represent business processes (BP), having the main objective to support an organization. Despite both are aiming at BPM, the techniques used are quite different in their semantics. While carrying out literature research, it has been found that there is no general representation of business process modeling is available that is expressive than the commercial modeling tools and techniques. Therefore, it is primarily conceived to provide an ontology mapping of modeling terms of Business Process Modeling Notation (BPMN), Unified Modeling Language (UML) Activity Diagrams (AD) and Event Driven Process Chains (EPC) to temporal logic. Being a formal system, first order logic assists in thorough understanding of process modeling and its application. However, our contribution is to devise a versatile conceptual categorization of modeling terms/constructs and also formalizing them, based on well accepted business notions, such as action, event, process, connector and flow. It is demonstrated that the new categorization of modeling terms mapped to formal temporal logic, provides the expressive power to subsume business process modeling techniques i.e. BPMN, UML AD and EPC.

Candidato: Federico Viglione Matricola: 730374 A.A. 2016/2017 I semi dell'eternità appartengono a delle signore, di professione lavandaie. Queste donne li custodiscono in una teiera riposta su una mensola. Quando alle prime, oscure, luci di ogni possibile alba, escono per le faccende, esse chiacchierano dei semi. Quando rientrano, al costante baluginare della stessa, abbacinante oscurità, sempre chiacchierano dei semi. I grembiuli, insudiciati e logori, sono di un bianco fulgido. Le espressioni riflettono, cordiali e marmoree, un'energia infinita. In casa, risuonano assordanti le campanelle. Mentre chiacchierano dei semi, sempre chiacchierano di ogni possibile cosa. Un (possibile) giorno venne una contadina: "Cosa crescerebbe", chiese, "se mi lasciaste piantare i vostri semi?".

Assume that a real-time programP T consisting of a number of parallel processes is executed on a system having a setPr of processors which are shared between the processes by a real-time schedulerS T. Assume that PT must meet some timing deadlines. We show that such an implementation ofP T can be represented as a transformationL(P T) and that the deadlines ofP T will be met if they are satisfied by the timing properties of the transformed program. The condition for feasibility of a real-time program executed under a scheduler is formalized and rules are provided for verification. The schedulerS T can be specifiedgenerically and applied to different programs, making it unnecessary to introduce low-level operations such as scheduling primitives into the programming language. Thus real-time program specification and Schedulability can be considered in the same framework and the timing properties of a program can be determined at the specification level. By separating the specification of the scheduler from that of the program, the feasibility of an implementation can be proved by considering a scheduling policy rather than its implementation details.

We extend the model of [VRV94] to express strong time-outs (and pre-emption): if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in languages such as ESTEREL (through instantaneous watchdogs) and LUSTRE (through the "current" operator).

We introduce Dynamic Networks of Timed Automata, an extension of (Networks of) Timed Automata useful for specifying concurrently executing timed-processes. The main difference with Timed Automata is that we allow the instantiation at run-time of multiple copies of automata. In this paper we also show an industrial case study where a system for monitoring a network of wireless devices is built applying Dynamic Networks of Timed Automata. The network is characterized by a high degree of dynamism, since its infrastructure is fixed but a big amount of its hosts continuously connect and disconnect. We see how extending XAL, an executable language for Timed Automata, we can first model our system, made of cooperating timed processes, and finally transform such model into an executable application. We also show how to model-check relevant properties of our application, expressing them through a temporal logic called TCTL and using existing formal methods and tools.

A fundamental problem in the design and development of embedded control systems is the verification of safety requirements. Formal methods, offering a mathematical way to specify and analyze the behavior of a system, together with the related support tools can successfully be applied in the formal proof that a system is safe. However, the complexity of real systems is such that automated tools often fail to formally validate such systems.

We describe a new conceptual methodology and related computational architecture called Knowl-Ž . edge-based Navigation of Abstractions for Visualization and Explanation KNAVE . KNAVE is a domain-independent framework specific to the task of interpretation, summarization, visualization, explanation, and interactive exploration, in a context-sensitive manner, of time-oriented raw data and the multiple levels of higher level, interval-based concepts that can be abstracted from these data. The KNAVE domain-independent exploration operators are based on the relations defined in the knowledge-based temporal-abstraction problem-solving method, which is used to abstract the data, and thus can directly use the domain-specific knowledge base on which that method relies. Thus, the domainspecific semantics are driving the domain-independent visualization and exploration processes, and the data are viewed through a filter of domain-specific knowledge. By accessing the domain-specific temporal-abstraction knowledge base and the domain-specific time-oriented database, the KNAVE modules enable users to query for domain-specific temporal abstractions and to change the focus of the Ž . visualization, thus reusing for a different task visualization and exploration the same domain model acquired for abstraction purposes. We focus here on the methodology, but also describe a preliminary evaluation of the KNAVE prototype in a medical domain. Our experiment incorporated seven users, a large medical patient record, and three complex temporal queries, typical of guideline-based care, that the users were required to answer andror explore. The results of the preliminary experiment have been encouraging. The new methodology has potentially broad implications for planning, monitoring, explaining, and interactive data mining of time-oriented data.

The solution of games is a key decision problem in the context of verification of open systems and program synthesis. We present an automata-theoretic approach to solve timed games. Our solution gives a general framework to solve many classes of timed games via a translation to tree automata, extending to timed games a successful approach to solve discrete games. Our approach relies on translating a timed automaton into a tree automaton that accepts all the trees corresponding to a given strategy of the protagonist. This construction exploits the region automaton introduced by Alur and Dill. We use our framework to solve timed Büchi games in exponential time, timed Rabin games in exponential time, Ctl games in exponential time and Ltl games in doubly exponential time. All these results are tight in the sense that they match the known lower bounds on these decision problems.

Finite identifiability of sets from positive data Dynamic epistemic logic Epistemic temporal logic Epistemic update Formal learning theory constitutes an attempt to describe and explain the phenomenon of learning, in particular of language acquisition. The considerations in this domain are also applicable in philosophy of science, where it can be interpreted as a description of the process of scientific inquiry. The theory focuses on various properties of the process of hypothesis change over time. Treating conjectures as informational states, we link the process of conjecture-change to epistemic update. We reconstruct and analyze the temporal aspect of learning in the context of dynamic and temporal logics of epistemic change. We first introduce the basic formal notions of learning theory and basic epistemic logic. We provide a translation of the components of learning scenarios into the domain of epistemic logic. Then, we propose a characterization of finite identifiability in an epistemic temporal language. In the end we discuss consequences and possible extensions of our work.

In this thesis, we study two fundamental problems that arise in the modeling of stochastic systems: (i) Validation of stochastic models against behavioral specifications such as temporal logics, and (ii) Discovery of kinetic parameters of stochastic biochemical models from behavioral specifications.

A fundamental problem in the design and development of embedded control systems is the verification of safety requirements. Formal methods, offering a mathematical way to specify and analyze the behavior of a system, together with the related support tools can successfully be applied in the formal proof that a system is safe. However, the complexity of real systems is such that automated tools often fail to formally validate such systems.

There has been a growing interest in investigating methodologies to support the development of secure systems in the software engineering research community. Recently, much attention has been focused on the modelling and analysis of security properties for systems at the software architecture design level. The potential benefits of this architecture level work are substantial: security flaws can be detected and removed earlier in the software development life-cycle. This reduces development time, reduces development cost, and improves the quality of the resulting system. As a result of this attention, a wide variety of approaches have been proposed in the literature. At this point, a survey for researchers involved in the problem of systematically modelling and analyzing software architecture design that have security properties would be of value to the community. This paper presents such a survey; it includes a discussion of semi-formal, formal, integrated semi-formal and formal, and aspect-oriented approaches. Comparison criteria are defined including: the kinds of notations used to model the security properties (e.g., Petri nets, temporal logic, etc.), whether the approach supports the manual or automated analysis of security properties, the specific security property modelled (e.g., authentication, role-based access control, etc.), and the kind of example system that has been used to illustrate the approach (information, distributed, etc.).

The paper attempts to give a solution to the Fitch’s paradox though the strategy of the reformulation of the paradox in temporal logic, and a notion of knowledge which is a kind of ceteris paribus modality. An analogous solution has been offered in a different context to solve the problem of metaphysical determinism.