Expressive completeness of temporal logic of trees

As a defacto industry standard, UML has been more and more widely used in software development. However, with the increase of software scale and complexity, deficiencies of UML are increasingly obvious. As the latest version of UML, UML2.0 has been improved and refined base on UML1.x. Whereas UML still lacks precise semantics which is difficult to analyze and validate the described model. In a unified temporal logic framework, temporal logic language XYZ/E can represent both static semantics and dynamic semantics. In addition, it supports stepwise refinement, model checking, as well as executable code automatically converted. Based on these, a practical scheme is proposed for modeling software with combining UML2.0 and XYZ/E, which also provides a formal basis for analysis and validation of the model.

: The question of whether branching-time temporal logic or linear-time temporal logic is best for reasoning about concurrent programs is one of the most controversial issues in logics of programs. Concurrent programs are usually modelled by labelled state-transition graphs in which some state is designated as the initial state. For historical reasons such graphs are called Kripke structures. In linear temporal logic operators are provided for describing events along a single time path (i.e., along a single path in a Kripke structure). In a branching-time logic the temporal operators quantify over the futures that are possible from a given state (i.e., over the possible paths that lead from a state). It is well known that the two types of temporal logic have different expressive powers. Linear temporal logic, for example, can express certain fairness properties that cannot be expressed in branching-time temporal logic. On the other hand, certain practical decision problems like model checking are easier for branching-time temporal logic than for linear temporal logic. This paper provides further insight on which type of logic is best. It is shown that if two finite Kripke structures can be distinguished by some formula that contains both branching-time and linear-time operators, then the structures can be distinguished by a formula that contains only branching time operators. Specifically, we show that if two finite Kripke structures can be distinguished by some formula of the logic CTL (i.e., if there is some CTL formula that is true in one but not in the other), then they can be distinguished by some formula of the logic CTL.

This paper bridges the advances in computer science and control to allow automatic synthesis of control strategies for complex dynamical systems which are guaranteed, by construction, to satisfy the desired properties even in the presence of adversary. The desired properties are expressed in the language of temporal logic. With its expressive power, a wider class of properties than safety and stability can be specified. The resulting system consists of a discrete planner that plans, in the abstracted discrete domain, a set of transitions of the system to ensure the correct behaviors and a continuous controller that continuously implements the plan. To address the computational difficulties in the synthesis of a discrete planner, we present a receding horizon based scheme for executing finite state automata that essentially reduces the synthesis problem to a set of smaller problems.

In this note, we consider the problem of introducing variables in temporal logic programs under the formalism of Temporal Equilibrium Logic, an extension of Answer Set Programming for dealing with linear-time modal operators. To this aim, we provide a definition of a first-order version of Temporal Equilibrium Logic that shares the syntax of first-order Linear-time Temporal Logic but has different semantics, selecting some Linear-time Temporal Logic models we call temporal stable models. Then, we consider a subclass of theories (called splittable temporal logic programs) that are close to usual logic programs but allowing a restricted use of temporal operators. In this setting, we provide a syntactic definition of safe variables that suffices to show the property of domain independence – that is, addition of arbitrary elements in the universe does not vary the set of temporal stable models. Finally, we present a method for computing the derivable facts by constructing a non-temporal logic program with variables that is fed to a standard Answer Set Programming grounder. The information provided by the grounder is then used to generate a subset of ground temporal rules which is equivalent to (and generally smaller than) the full program instantiation.

Temporal logic query checking was first introduced by W. Chan in order to speed up design understanding by discovering properties not known a priori. A query is a temporal logic formula containing a special symbol ?/sub 1/, known as a placeholder. Given a Kripke structure and a propositional formula /spl phi/, we say that /spl phi/ satisfies the query if replacing the placeholder by /spl phi/ results in a temporal logic formula satisfied by the Kripke structure. A solution to a temporal logic query on a Kripke structure is the set of all propositional formulas that satisfy the query. Query checking helps discover temporal properties of a system and, as such, is a useful tool for model exploration. In this paper, we show that query checking is applicable to a variety of model exploration tasks, ranging from invariant computation to test case generation. We illustrate these using a Cruise Control System. Additionally, we show that query checking is an instance of a multi-valued model checking of Chechik et al. This approach enables us to build an implementation of a temporal logic query checker, TLQSolver, on top of our existing multi-valued model checker /sub /spl chi//Chek. It also allows us to decide a large class of queries and introduce witnesses for temporal logic queries-an essential notion for effective model exploration.

An important field of application of intelligent logical agents, where rationality plays a main role, is that of automated negotiation. Our work is related to the use of argumentation in the field of negotiation. In particular, we are interested in contract violations, and in the construction of justifications to motivate the violation itself and recover if possible the contract on modified conditions. We propose a temporal modal logic language able to support and depict the arguments/justification used in dialectical disputes and we consider suitable algorithms and mechanisms to introduce and manage justifications.

Vibes: A visual language for specifying behavioral requirements of algorithms

Wireless networks are more vulnerable to cyberattacks than cable networks. Compared with the misuse intrusion detection techniques based on pattern matching, the techniques based on model checking U+0028 MC U+0029 have a series of comparative advantages. However, the temporal logics employed in the existing latter techniques cannot express conveniently the complex attacks with synchronization phenomenon. To address this problem, we formalize a novel temporal logic language called attack signature description language U+0028 ASDL U+0029. On the basis of it, we put forward an ASDL model checking algorithm. Furthermore, we use ASDL programs, which can be considered as temporal logic formulas, to describe attack signatures, and employ other ASDL programs to create an audit log. As a result, the ASDL model checking algorithm can be presented for automatically verifying whether or not the latter programs satisfy the formulas, that is, whether or not the audit log coincides with the attack signatures. Thus, an intrusion detection algorithm based on ASDL is obtained. The case studies and simulations show that the new method can find coordinated chop-chop attacks.

The behavior of complex software-intensive systems of systems often only fully emerges during operation, when all systems interact with each other and with their environment. Runtime monitoring approaches are thus used to detect deviations from the expected behavior, which is commonly defined by engineers, e.g., using temporal logic or domain-specific languages. However, the deep domain knowledge required to specify constraints is often not available during the development of systems of systems with multiple teams independently working on heterogeneous components. In this paper, we thus describe our ongoing PhD research to automatically mine constraints for runtime monitoring from recorded events. Our approach mines constraints on event occurrence, timing, data, and combinations of these properties. The approach further presents the mined constraints to users offering multiple ranking strategies and can also be used to support users in system evolution scenarios.

An important question of knowledge management is how we can support domain experts in formulating their domain knowledge and in making this expertise available via knowledge based systems. Critiquing systems are a special kind of knowledge based system. These systems provide context sensitive advice, and rationale to an artifact (for example charts, Web pages and so on) designed by a user. This is realized by delivering so called critiques, which contain relevant information for the user to the task at hand. We present a visual programming language called VisualCiLa, which allows design experts to formulate such critiques. It is based on a special subset of first order logic and a special form of text construction. VisualCiLa is built on top of a pipe-, filter and collector-metaphor and allows users to plug critiques together by placing tiles on a spreadsheet. Furthermore, VisualCiLa supports users in simulating the inference mechanism, which is represented by the flow of objects through the pipes. Filters and collectors visualize the functionality of inference and support the debugging process of such critiques. We believe that this language is a framework which allows design experts to formulate, to test, and to debug their expertise as critiquing knowledge.

The Datalog syntax we have been considering so far corresponds to a very restricted subset of first order logic and is often referred to as pure Datalog. Several extensions of pure Datalog have been proposed in the literature or are currently under investigation.

On the interpretability of arithmetic in temporal logic

Recent development of logic programming languages based on linear logic suggests a successful direction to extend logic programming to be more expressive and more efficient. The treatment of formulasas-resources gives us not only powerful expressiveness, but also efficient access to a large set of data. However, in linear logic, whole resources are kept in one context, and there is no straight way to represent complex data structures as resources. For example, in order to represent an ordered list and time-dependent data, we need to put additional indices for each resource formula. This paper describes a logic programming language, called TLLP, based on intuitionistic temporal linear logic. This logic, an extension of linear logic with some features from temporal logics, allows the use of the modal operators '?'(next-time) and '?'(always) in addition to the operators used in intuitionistic linear logic. The intuitive meaning of modal operators is as follows: ? B means that B can be used exactly once at the next moment in time; ? B means that B can be used exactly once any time; !B means that B can be used arbitrarily many times (including 0 times) at any time. We first give a proof theoretic formulation of the logic of the TLLP language. We then present a series of resource management systems designed to implement not only interpreters but also compilers based on an extension of the standard WAM model.

Time is the grand stage where human activities take place (rational or otherwise). And the view of a branching temporal universe, or tree of possible events, with our actual history linearly advancing through it, is a widely shared cultural idea, not confined to Academia (cf. Borges brilliant 1941 essayEl Jardin de senderos que se bifurcan). Even though logic is often considered a study of timeless propositions, temporal languages and logics over tree structures have a long tradition. Philosophers have studied temporal structure and temporal reasoning since the 1950s, from the ‘tense logic’ of Prior (1967) to the ‘STIT’ system of Belnap et al. (2001). Moreover, starting from 1970s, computer scientists have joined in, and developed many further flavours of temporal logic, with major strands such as Pnueli on program correctness (Manna and Pnueli 1991), Emerson and Clarke on process specification and verification (Emerson and Clarke 1980, 1982), Reiter on the situation calculus in AI (Reiter 2001), and Thomas on the automata-theoretic foundations of computing (Thomas 1990). In addition, the pure firstand second-order logic of tree-like structures, starting from Rabin’s classic decidability result (Rabin 1969), provides deeper background (cf. Gradel et al. (2002)). The chapter by Hodkinson and Reynolds on ‘Temporal Logic’ in the Handbook of Modal Logic (Hodkinson and Reynolds 2006) brings together many of these trends in one mathematical narrative. But the field of reasoning in, and about, time can be mapped out in many further ways: Van Benthems chapter ‘Temporal Logic’ in the

This paper shows the relation between linear temporal logic and theory of languages of concurrent processes. To this purpose, we give an algebraic correspondence between temporal logic systems and some non deterministic sequential machines. This correspondence lies on an effective method which composes machines as temporal operators. So we can synthetise processes from temporal logic formulas and solve logic problems by algorithms applied to machines.KeywordsTemporal LogicLinear Temporal LogicTemporal Logic FormulaNous AllonsBranch Time Temporal LogicThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.