Descriptive dynamic logic and its application to reflective architectures

Description logics provide powerful languages for representing and reasoning about knowledge of static application domains. The main strength of description logics is that they offer considerable expressive power going far beyond propositional logic, while reasoning is still decidable. There is a demand to bring the power and character of description logics into the description and reasoning of dynamic application domains which are characterized by actions. In this paper, based on a combination of the propositional dynamic logic PDL, a family of description logics and an action formalism constructed over description logics, we propose a family of dynamic description logics DDL(X @) for representing and reasoning about actions, where X represents well-studied description logics ranging from the to the , and X @ denotes the extension of X with the @ constructor. The representation power of DDL(X @) is reflected in four aspects. Firstly, the static knowledge of application domains is represented as RBoxes and acyclic TBoxes of the description logic X. Secondly, the states of the world and the pre-conditions of atomic actions are described by ABox assertions of the description logic X @, and the post-conditions of atomic actions are described by primitive literals of X @. Thirdly, starting with atomic actions and ABox assertions of X @, complex actions are constructed with regular program constructors of PDL, so that various control structures on actions such as the "Sequence", "Choice", "Any-Order", "Iterate", "If-Then-Else", "Repeat-While" and "Repeat-Until" can be represented. Finally, both atomic actions and complex actions are used as modal operators for the construction of formulas, so that many properties on actions can be explicitly stated by formulas. A tableau-algorithm is provided for deciding the satisfiability of DDL(X @)-formulas; based on this algorithm, reasoning tasks such as the realizability, executability and projection of actions can be effectively carried out. As a result, DDL(X @) not only offers considerable expressive power going beyond many action formalisms which are propositional, but also provides decidable reasoning services for actions described by it.

Revising knowledge bases (KBs) in description logics (DLs) in a syntax-independent manner is an important, nontrivial problem for the ontology management and DL communities. Several attempts have been made to adapt classical model-based belief revision and update techniques to DLs, but they are restricted in several ways. In particular, they do not provide operators or algorithms for general DL KB revision. The key difficulty is that, unlike propositional logic, a DL KB may have infinitely many models with complex (and possibly infinite) structures, making it difficult to define and compute revisions in terms of models. In this paper, we study general KBs in a specific DL in the DL-Lite family. We introduce the concept of features for such KBs, develop an alternative semantic characterization of KBs using features (instead of models), define two specific revision operators for KBs, and present the first algorithm for computing best approximations for syntax-independent revisions of KBs.

Knowledge is one of the most precious resources of an organization. Every organization wishes to preserve and fully utilize its knowledge. Within organization knowledge is present in various forms, may be in the minds of workers or in documented form. In documented form the knowledge has various representation schemes such as frames, scripts, lists, decision trees and decision tables etc. We have proposed a transformation method to optimally transform knowledge present in decision trees and decision tables into knowledge base. According to our proposal, the knowledge present in these two representation schemes should first be converted into corresponding set of human interpretable rules by using some existing transformation algorithms. The decision tree should be converted directly into set of human interpretable rules but for decision table transformation, two ways are adopted; either it should be converted first into decision tree and then to set of rules or, should be converted directly into set of rules. Once the set of rules is obtained then it will be optimized by using some existing optimization algorithms and unnecessary conditions will be omitted. After rules optimization process, comparison with the existing rules in the knowledge base is carried out. If these optimized rules are not found in the knowledge base, it should be added. If some rules need updation, then these should be added after updation. During comparison those rules which already exist in the knowledge base should be omitted.

The dynamic description logic DDL provides formalism for describing dynamic system in the semantic Web environment Model checking is a formal verification method based on state transition system. In this paper, we bring dynamic description logic into model checking. Firstly, state transition systems considered in model checking are modeled as complex actions in dynamic description logic. Secondly, a kind of temporal description logic DL-CTL is introduced to specify temporal properties on state transition systems, where DL-CTL is a DL-based extension of propositional branch-time temporal logic CTL. Finally, verification algorithm is presented with the help of reasoning mechanisms provided by description logic.

As a family of dynamic description logics, DDL(X) is constructed by embracing actions into the description logic X, where X represents well-studied description logics ranging from the ALC to the SHOIQ. The usage of distributed computation techniques in reasoning is an important premise for the adoption of Dynamic Description Logics in a real-world setting. Practical scalability of DDL(X) reasoning inspired recently a proposal of Distributed Dynamic Description Logics (D3L) framework. D3L is a natural generalization of the DDL(X) framework, which is designed to model the distributed dynamically-changing knowledge repositories interconnected by semantic mappings and to accomplish reasoning in distributed, heterogeneous environments. In this paper, we investigate the reasoning mechanisms in D3L and propose a tableau-based reasoning algorithm for D3L, built as a composition of the state of the art tableaux reasoners for DDL(X).

A formal language of two-valued logic is developed, whose terms are formulas of the language of Kleene's three-valued logic. The atomic formulas of the former language are pairs of formulas of the latter language joined by “consequence” operators. These operators correspond to the three “sensible” types of consequence (strong-strong, strong-weak and weak-weak) in Kleene's logic in analogous way as the implication connective in the classical logic corresponds to the classical consequence relation. The composed formulas of the considered language are built from the atomic ones by means of the classical connectives and quantifiers. A deduction system for the developed language is given, consisting of a set of decomposition rules for sequences of formulas. It is shown that the deduction system is sound and complete.

One of the most appealing characteristics of logic programs is the natural and abundant non-determinism of execution. This non-determinism allows a non-conventional computer to pursue highly parallel computation. Considerable effort has been expended exploiting this potential. The AND/OR Process Model in Conery's dissertation [1] and Concurrent Prolog by Shapiro [2] are two famous pioneering efforts in this area. They are frequently referenced in the literature as bases of improvement and comparison.

Answering regular path queries in expressive Description Logics via alternating tree-automata

The paper introduces a knowledge representation language that combines the event calculus with description logic in a logic programming framework. The purpose is to provide the user with an expressive language for modelling and analysing systems that evolve over time. The approach is exemplified with the logic programming language as implemented in the Fusemate system. The paper extends Fusemate's rule language with a weakly DL-safe interface to the description logic $\cal ALCIF$ and adapts the event calculus to this extended language. This way, time-stamped ABoxes can be manipulated as fluents in the event calculus. All that is done in the frame of Fusemate's concept of stratification by time. The paper provides conditions for soundness and completeness where appropriate. Using an elaborated example it demonstrates the interplay of the event calculus, description logic and logic programming rules for computing possible models as plausible explanations of the current state of the modelled system.

We present some results on semantics for logic programs. We interpret logic programs in Kripke models. They connect the area of logic programming and that of nonclassical logics. New connectives are carried over dynamic logic to logic programs, resulting in so-called predicate programs. A wide class of predicate programs is shown to have the same meaning as formulas of dynamic logic with context-free programs. This allows to discuss the known problem of introducing the negation into logic programs in new light.

Description logics (DLs) and rule-based systems are two prominent families of knowledge representation formalisms. While DLs are focused on describing and reasoning about conceptual knowledge, rules are focused on answering queries about facts in the knowledge base. So far, research on DLs has been largely isolated from the research on rules. With the advent of the Semantic Web, however, it became apparent that neither formalism alone can cover all the practical use cases. The integration between DLs and rules, however, is technically challenging due to significant differences in the underlying semantic assumptions. In particular, DLs are based on standard first-order semantics and open-world assumption, whereas rules typically employ closed-world semantics based on a variant of circumscription. In my talk, I shall present an overview of the benefits of integrating DLs and rules in a coherent semantic framework, and shall discuss the main challenges in achieving a tight integration. I shall present an overview of the approaches currently discussed in literature. Finally, I shall present in more detail the approach that is based on the nonmonotonic logic MKNF by Lifschitz. This approach is tight in the sense that DLs and rules are given a common model-theoretic semantics. Furthermore, it is faithful in the sense that it is compatible with the original semantics of both DLs and rules. Finally, it is expressive and can naturally capture many of the existing proposals. I shall discuss the definitions of the semantics of the hybrid formalism, present a decision procedure for a particular decidable fragment, and discuss the complexity bounds of reasoning.

Total correctness assertions (TCAs) have long been considered a natural formalization of successful program termination. However, research dating back to the 1980s suggests that validity of TCAs is a notion of limited interest; we corroborate this by proving compactness and Herbrand properties for the valid TCAs, defining in passing a new sound, complete, and syntax-directed deductive system for TCAs. It follows that proving TCAs whose truth depends on underlying inductive data-types is impossible in logics of programs that are sound for all structures, such as dynamic logic based on Segerberg's PDL, even when augmented with powerful first-order theories like Peano arithmetic. Harel's convergence rule bypasses this difficulty, but is methodologically and conceptually problematic, in addition to being unsound for general validity. We propose instead to bind variables to inductive data via DL's box operator, leading to an alternative formalization of termination assertions, which we dub inductive TCA (ITCA). We observe that a TCA is provable in Harel's DL exactly when the corresponding ITCA is provable in Segerberg's DL, thereby showing that the convergence rule is not foundationally or practically necessary. We also show that validity of ITCAs is directly reducible to validity of partial correctness assertions, confirming the foundational importance of the latter.

We aim to demonstrate that automated deduction techniques, in particular those following the model computation paradigm, are very well suited for database schema/query reasoning. Specifically, we present an approach to compute completed paths for database or XPath queries. The database schema and a query are transformed to disjunctive logic programs with default negation, using a description logic as an intermediate language. Our underlying deduction system, KRHyper, then detects if a query is satisfiable or not. In case of a satisfiable query, all completed paths – those that fulfill all given constraints – are returned as part of the computed models.

For designing Entity-relationship(ER) schemas, an interesting topic is how to transform ER schemas into knowledge bases (KBs) in description logics (DLs). It is significance in translations that one can use automated DL reasoning services to support the development and maintenance of correct ER schemas. This paper proposed a faithful translation, which translates ER schemas into KBs in the description logic ALDL and allows us to reduce reasoning on ER schemas to finite models reasoning on ALDL KBs.

Similarity-based relaxed instance queries