Managing Change in Graph-structured Data Using Description Logics (long version with appendix)

04/16/2014 ∙ by Shqiponja Ahmetaj, et al. ∙ Free University of Bozen-Bolzano TU Wien 0

In this paper, we consider the setting of graph-structured data that evolves as a result of operations carried out by users or applications. We study different reasoning problems, which range from ensuring the satisfaction of a given set of integrity constraints after a given sequence of updates, to deciding the (non-)existence of a sequence of actions that would take the data to an (un)desirable state, starting either from a specific data instance or from an incomplete description of it. We consider an action language in which actions are finite sequences of conditional insertions and deletions of nodes and labels, and use Description Logics for describing integrity constraints and (partial) states of the data. We then formalize the above data management problems as a static verification problem and several planning problems. We provide algorithms and tight complexity bounds for the formalized problems, both for an expressive DL and for a variant of DL-Lite.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The complex structure and increasing size of information that has to be managed in today’s applications calls for flexible mechanisms for storing such information, making it easily and efficiently accessible, and facilitating its change and evolution over time. The paradigm of graph structured data (GSD) [32] has gained popularity recently111Graph structured data models have their roots in work done in the early ’90s, see, e.g., [20]. as an alternative to traditional relational DBs that provides more flexibility and thus can overcome the limitations of an a priori imposed rigid structure on the data. Indeed, differently from relational data, GSD do not require a schema to be fixed a priori. This flexibility makes them well suited for many emerging application areas such as managing Web data, information integration, persistent storage in object-oriented software development, or management of scientific data. Concrete examples of models for GSD are RDFS [14], object-oriented data models, and XML.

In GSD, information is represented by means of a node and edge labeled graph, in which the labels convey semantic information. The representation structures underlying many standard knowledge representation formalisms, and in particular Description Logics (DLs) [5] are paradigmatic examples of GSD. Indeed, in DLs the domain of interest is modeled by means of unary relations (a.k.a. concepts) and binary relations (a.k.a. roles), and hence the first-order interpretations of a DL knowledge base (KB) can be viewed as node and edge labeled graphs. DLs have been advocated as a proper tool for data management [26], and are very natural for describing complex knowledge about domains represented as GSD. A DL KB comprises an assertional component, called ABox, which is often viewed as a possibly incomplete instance of GSD, and a logical theory called terminology or TBox, which can be used to infer implicit information from the assertions in the ABox. An alternative possibility is to view the finite structures over which DLs are interpreted as (complete) GSD, and the KB as a description of constraints and properties of the data. Taking this view, DLs have been applied, for example, for the static analysis of traditional data models, such as UML class diagrams [11] and Entity Relationship schemata [3]. Problems such as the consistency of a diagram are reduced to KB satisfiability in a suitable DL, and DL reasoning services become tools for managing GSD.

In this paper, we follow the latter view, but aim at using DLs not only for static reasoning about data models, but also for reasoning about the evolution and change over time of GSD that happens as the result of executing actions. The development of automated tools to support such tasks is becoming a pressing problem, given the large amounts and complexity of GSD currently available. Having tools to understand the properties and effects of actions is important and provides added value for many purposes, including application development, integrity preservation, security, and optimization. Questions of interest are, e.g.:

  • Will the execution of a given action preserve the integrity constraints, for every initial data instance?

  • Is there a sequence of actions that leads a given data instance into a state where some property (either desired or not) holds?

  • Does a given sequence of actions lead every possible initial data instance into a state where some property necessarily holds?

The first question is analogous to a classic problem in relational databases: verifying consistency of database transactions. The second and third questions are classic questions in AI (called planning and projection, respectively).

In this paper we address these and other related questions, develop tools to answer them, and characterize the computational properties of the underlying problems. The role of DLs in our setting is manifold, and we propose a very expressive DL that is suitable for: (i) modeling sophisticated domain knowledge, (ii) specifying conditions on the state that should be reached (goal state), and (iii) specifying actions to evolve GSD over time. For the latter, we introduce a simple yet powerful language in which actions are finite sequences of (possibly conditional) insertions and deletions performed on concepts and roles, using complex DL concepts and roles as queries. Our results are quite general and allow for analyzing data evolution in several practically relevant settings, including RDF data under constraints expressed in RDFS or OWL. Via the standard reification technique [11], they also apply to the more traditional setting of relational data under schemas expressed in conceptual models (e.g., ER schemas, or UML class diagrams), or to object-oriented data.

In this setting, we address first the static verification problem, that is, the problem of verifying whether for every possible state satisfying a given set of constraints (a given KB), the constraints are still satisfied in the state resulting from the execution of a given (complex) action. We develop a novel technique similar in spirit to regression in reasoning about actions [27], and are able to show that static verification is decidable. We provide tight complexity bounds for it, using two different DLs as domain languages. Specifically, we provide a tight coNExpTime bound for the considered expressive DL, and a tight cobound for a variation of DL-Lite [16]. For our setting, we then study different variants of planning. We define a plan as a sequence of actions that leads a given structure into a state where some property (either desired or not) holds. Then we study problems such as deciding the existence of a plan, both for the case where the initial structure is fully known, and where only a partial description of it is available, and deciding whether a given sequence of actions is always a plan for some goal. Since the existence of a plan (of unbounded length) is undecidable in general, even for lightweight DLs and resctricted actions, we also study plans of bounded length. We provide tight complexity bounds for the different considered variants of the problem, both for lightweight and for expressive DLs. This paper adds an appendix with proofs to [1], some of the results were published in preliminary form [19].

2 An Expressive DL for Modeling GSD

We now define the DL , used to express constraints on GSD. It extends the standard with Boolean combinations of axioms, a constructor for a singleton role, union, difference and restrictions of roles, and variables as place-holders for individuals. The importance of these constructors will be become clear in Sections 3 and 4.

We assume countably infinite sets of role names, of concept names, of individual names, and of variables. Roles are defined inductively: (i) if , then and (the inverse of ) are roles; (ii) if , then is also a role; (iii) if are roles, then , and are also roles; and (iv) if is a role and is a concept, then is a role. Concepts are defined inductively as well: (i) if , then is a concept; (ii) if , then is a concept (called nominal); (iii) if , are concepts, then , , and are also concepts; (iv) if is a role, is a concept, and is a non-negative integer, then , , , and are also concepts.

A concept (resp., role) inclusion is an expression of the form , where are concepts (resp., roles). Expressions of the form and , where , is a concept, and is a role, are called concept assertions and role assertions, respectively. Concepts, roles, inclusions, and assertions that have no variables are called ordinary. We define (-)formulae inductively: (i) every inclusion and every assertion is a formula; (ii) if , are formulae, so are , , and . A formula with no variables is called knowledge base (KB).

As usual in DLs, the semantics is given in terms of interpretations. An interpretation is a pair where is the domain, for each , for each , and for each . For the ordinary roles of the form , we let , and for ordinary roles of the form , we let . The function is extended to the remaining ordinary concepts and roles in the usual way, see [5]. Assume an interpretation . For an ordinary inclusion , satisfies (in symbols, ) if . For an ordinary assertion (resp., ), satisfies (in symbols, ) if (resp., ). The notion of satisfaction is extended to knowledge bases as follows: (i) if and ; (ii) if or ; (iii) if . If , then is a model of . The finite satisfiability (resp., unsatisfiability) problem is to decide given a KB if there exists (resp., doesn’t exist) a model of with finite.

A lower bound for finite satisfiability in follows from the work of Tobies [35]. Using well-known techniques due to Borgida [13], a matching upper bound can be shown by a direct translation into the two variable fragment with counting, for which finite satisfiability is in [31]. Hence, the finite satisfiability problem for KBs has the same computational complexity as for the standard :

Theorem 1.

Finite satisfiability of KBs is -complete.

We are interested in the problem of effectively managing GSD satisfying the knowledge represented in a DL KB . Hence, we must assume that such data are of finite size, i.e., they correspond naturally to finite interpretations that satisfy the constraints in . In other words, we consider configurations of the GSD that are finite models of .

3 Updating Graph Structured Data

We now define an action language for manipulating GSD, i.e., finite interpretations. The basic actions allow one to insert or delete individuals from extensions of concepts, and pairs of individuals from extensions of roles. The candidates for additions and deletions are instances of complex concepts and roles. Since our DL supports nominals and singleton roles , actions can be defined to add/remove a single individual to/from a concept, or a pair of individuals to/from a role. We allow also for action composition and conditional actions. Note that the action language introduced here is a slight generalization of the one in [19].

Definition 1 (Action language).

A basic action is defined by the following grammar:

where is a concept name, is an arbitrary concept, is a role name, and is an arbitrary role. Then (complex) actions are given by the following grammar:

where is a basic action, is an arbitrary -formula, and denotes the empty action.

A substitution is a function from to . For a formula, an action or an action sequence , we use to denote the result of replacing in every occurrence of a variable by the individual . An action is ground if it has no variables. An action is called a ground instance of an action if for some substitution .

Intuitively, an application of an action on an interpretation stands for the addition of the content of to . Similarly, stands for the removal of from . The two operations can also be performed on extensions of roles. Composition stands for successive action execution, and a conditional action expresses that is executed if the interpretation is a model of , and is executed otherwise. If then we have an action with a simple pre-condition as in classical planning languages, and we write it as , omitting .

To formally define the semantics of actions, we first introduce the notion of interpretation update.

Definition 2 (Interpretation update).

Assume an interpretation and let be a concept or role name. If is a concept, let , otherwise, if is a role, let . Then, (resp., ) denotes the interpretation such that , and

  1. (resp., ), and

  2. , for all symbols .

Now we can define the semantics of ground actions:

Definition 3.

Given a ground action , we define a mapping from interpretations to interpretations as follows:

In the following, we assume that interpretations are updated using the above language.

Example 1.

The following interpretation represents (part of) the project database of some research institute. There are two active projects, and there are three employees that work in the active projects.

We assume constants with for projects, and analogously constants for employees. The following action captures the termination of project , which is removed from the active projects and added to the finished ones. The employees working only for this project are removed.

The interpretation that reflects the status of the database after action looks as follows:

Note that we have not defined the semantics of actions with variables, i.e., for non-ground actions. In our approach, all variables of an action are seen as parameters whose values are given before execution by a substitution with actual individuals, i.e., by grounding.

Example 2.

The following action with variables , , transfers the employee from project to project :

Under the substitution with , , and , the action first checks whether is an (instance of) employee, , are projects, and works for . If yes, it removes the link between and , and creates a link between and . If any of the checks fails, it does nothing.

4 Capturing Action Effects

In this section we present our core technical tool: a transformation that rewrites incorporating the possible effects of an action . Intuitively, the models of are exactly the interpretations such that applying on leads to a model of . In this way, we can effectively reduce reasoning about changes in any database that satisfies a given , to reasoning about a single KB. In the next section we use this transformation to solve a wide range of data management problems by reducing them to standard DL reasoning services, such as finite (un)satisfiability. This transformation can be seen as a form of regression [27], which incorporates the effects of a sequence of actions ‘backwards’, from the last one to the first one.

Definition 4.

Given a KB , we use to denote the KB that is obtained from by replacing every name by the (possibly more complex) expression . Given a KB and an action , we define as follows:

Note that the size of might be exponential in the size of . We now show that this transformation correctly captures the effects of complex actions.

Theorem 2.

Assume a ground action and a KB . For every interpretation , we have iff .

Proof.

We define as follows: , , and . We prove the claim by induction on . In the base case where and , we have and by definition, and thus the claim holds.

Assume . Let , that is, coincides with except that . For every KB , iff (This can be proved by a straightforward induction on the structure of the expressions in ). In particular, iff . Since , we get iff . By the induction hypothesis, iff , thus iff . Since by definition, we obtain iff as desired.

For the cases , , and , the argument is analogous.

Finally, we consider , and assume an arbitrary . We consider the case where ; the case where is analogous. By definition . By the induction hypothesis we know that iff , so iff . Since and , it follows that iff . ∎

This theorem will be important for solving the reasoning problems we study below.

Example 3.

The following KB expresses constraints on the project database of our running example: all projects are active or finished, the domain of are the employees, and its range the projects.

By applying the transformation above to and , we obtain the following KB :

5 Static Verification

In this section, we consider the scenario where DL KBs are used to impose integrity constraints on GSD. One of the most basic reasoning problems for action analysis in this setting is static verification, which consists in checking whether the execution of an action always preserves the satisfaction of integrity constraints given by a KB.

Definition 5 (The static verification problem).

Let be a KB. We say that an action is -preserving if for every ground instance of and every finite interpretation , we have that implies . The static verification problem is defined as follows:

  1. Given an action and a KB , is -preserving?

Using the transformation above, we can reduce static verification to finite (un)satisfiability of KBs: An action is not -preserving iff some finite model of does not satisfy , where is a ‘canonical’ grounding of . Formally, we have:

Theorem 3.

Assume a (complex) action and a KB . Then the following are equivalent:

  1. The action is not -preserving.

  2. is finitely satisfiable, where is obtained from by replacing each variable with a fresh individual name not occurring in and .

Example 4.

The action from Example 1 is not -preserving: , but since the concept inclusion is violated. This is reflected in the fact that , as can be readily checked. Intuitively, values removed from should also be removed from , as in the following -preserving action:

The above theorem provides an algorithm for static verification, which we can also use to obtain tight bounds on the computational complexity of the problem. Indeed, even though may be of size exponential in , we can avoid to generate it all at once. More precisely, we use a non-deterministic polynomial time many-one reduction that builds only for a fragment of that corresponds to one fixed way of choosing one of or for each conditional action in (intuitively, we can view as one conjunct of the DNF of , where axioms and assertions are treated as propositions). Such a has polynomial size, and it can be built non-deterministically in polynomial time. It is not hard to show that is finitely satisfiable iff there is some choice such that is finitely satisfiable. By Theorem 1, the latter test can be done in non-deterministic exponential time, hence from Theorem 3 we obtain:

Theorem 4.

The problem (SV) is co-complete in case the input KB is expressed in .

We note that in our definition of the (SV) problem, in addition to the action to be verified, one has as input only one KB expressing constraints. We can also consider other interesting variations of the problem where, for example, we have a pair of KBs and instead of (or in addition to) and we want to decide whether executing the action on any model of (and ) leads to a model of (and ). The reasoning techniques and upper bounds presented above also apply to these generalized settings.

Lowering the Complexity

The goal of this section is to identify a setting for which the computational complexity of static verification is lower. The natural way to achieve this is to consider as constraint language a DL with better computational properties, such as the logics of the family [16].

Unfortunately, we cannot achieve tractability, since static verification is cohard even in a very restricted setting, as shown next.

Theorem 5.

The static verification problem is co-hard already for KBs of the form , where each is a concept name, and ground sequences of basic actions of the forms and .

We next present a rich variant of , which we call , for which the static verification problem is in co. It supports (restricted) Boolean combinations of inclusions and assertions, and allows for complex concepts and roles in assertions. As shown below, this allows us to express the effects of actions inside KBs.

Definition 6.

The logic is defined as follows:

  1. Concept inclusions have the form or , with

  2. Role inclusions in have the form or , with .

  3. Role assertions are defined as for , but in concept assertions , we require , where is the smallest set of concepts such that:

    1. ,

    2. for all ,

    3. for all roles ,

    4. for all .

  4. Formulae and KBs are defined as for , but the operator may occur only in front of assertions.

A KB is a KB that satisfies the following restrictions:

  1. is a conjunction of inclusions and assertions, and

  2. all assertions in are basic assertions of the forms with , and with .

We make the unique name assumption (UNA): for every pair of individuals , and interpretation , we have .

We need to slightly restrict the action language, which involves allowing only Boolean combinations of assertions to express the condition in actions of the form .

Definition 7.

A (complex) action is called simple if (i) no (concept or role) inclusions occur in , and (ii) all concepts of are from .

We next characterize the complexity of finite satisfiability in .

Theorem 6.

Finite satisfiability of KBs is -complete.

is expressive enough to allow us to reduce static verification for simple actions to finite unsatisfiability, and similarly as above, we can use a non-deterministic polynomial time many-one reduction (from the complement of static verification to finite unsatisfiability) to obtain a coupper bound on the complexity of static verification. This bound is tight, even if we allow only actions with preconditions rather than full conditional actions. We note that all lower bounds in the next section also hold for this restricted case.

Theorem 7.

The static verification problem for KBs and simple actions is co-complete.

6 Planning

We have focused so far on ensuring that the satisfaction of constraints is preserved when we evolve GSD. But additionally, there may be desirable states of the GSD that we want to achieve, or undesirable ones that we want to avoid. For instance, one may want to ensure that a finished project is never made active again. This raises several problems, such as deciding if there exists a sequence of actions to reach a state with certain properties, or whether a given sequence of actions always ensures that a state with certain properties is reached. We consider now these problems and formalize them by means of automated planning.

We use DLs to describe states of KBs, which may act as goals or preconditions. A plan is a sequence of actions from a given set, whose execution leads an agent from the current state to a state that satisfies a given goal.

Definition 8.

Let be a finite interpretation, a finite set of actions, and a KB (the goal KB). A finite sequence of ground instances of actions from is called a plan for from (of length ), if there exists a finite set with such that , where .

Recall that actions in our setting do not modify the domain of an interpretation. To support unbounded introduction of values in the data, the definition of planning above allows for the domain to be expanded a-priori with a finite set of fresh domain elements.

We can now define the first planning problems we study:

  1. Given a set of actions, a finite interpretation , and a goal KB , does there exist a plan for from ?

  2. Given a set of actions and a pair , of formulae, does there exist a substitution and a plan for from some finite with ?

(P1) is the classic plan existence problem, formulated in the setting of GSD. (P2) also aims at deciding plan existence, but rather than the full actual state of the data, we have as an input a precondition KB, and we are interested in deciding the existence of a plan from some of its models. To see the relevance of (P2), consider the complementary problem: a ‘no’ instance of (P2) means that, from every relevant initial state, (undesired) goals cannot be reached. For instance, and may be used to check whether starting with GSD that satisfies the integrity constraints and contains some finished project , it is possible to make an active project again.

Example 5.

Recall the interpretation and the action from Example 4, and the substitution from Example 2, which gives us the following ground instance of :

The following goal KB requires that is not an active project, and that is an employee.

A plan for from is the sequence of actions . The interpretation that reflects the status of the data after applying looks as follows:

Clearly, .

Unfortunately, these problems are undecidable in general, which can be shown by a reduction from the Halting problem for Turing machines.

Theorem 8.

The problems (P1) and (P2) are undecidable, already for KBs and simple actions.

Intuitively, problem (P1) is undecidable because we cannot know how many fresh objects need to be added to the domain of , but it becomes decidable if the size of in Definition 8 is bounded. It is not difficult to see that problem (P2) remains undecidable even if the domain is assumed fixed (as the problem definition quantifies existentially over interpretations, one can choose interpretations with sufficiently large domains). However, also (P2) becomes decidable if we place a bound on the length of plans. More precisely, the following problems are decidable.

  1. Given a set of actions, a finite interpretation , a goal KB , and a positive integer , does there exist a plan for from where ?

  2. Given a set of actions , a pair of formulae, and a positive integer , does there exist a substitution and a plan of length for from some finite interpretation with ?

We now study the complexity of these problems, assuming that the input bounds are coded in unary. The problem (P1b) can be solved in polynomial space, and thus is not harder than deciding the existence of a plan in standard automated planning formalisms such as propositional STRIPS [15]. In fact, the following lower bound can be proved by a reduction from the latter formalism, or by an adaptation of the Turing Machine reduction used to prove undecidability in Theorem 8.

Theorem 9.

The problem (P1b) is -complete for KBs.

Now we establish the complexity of (P2b), both in the general setting (i.e., when and are in ), and for the restricted case of KBs and simple actions. For (SV), considering the latter setting allowed us to reduce the complexity from coto co. Here we obtain an analogous result and go from -completeness to -completeness.

Theorem 10.

The problem (P2b) is -complete. It is -complete if are expressed in and all actions in are simple.

Now we consider three problems that are related to ensuring plans that always achieve a given goal, no matter what the initial data is. They are variants of the so-called conformant planning, which deals with planning under various forms of incomplete information. In our case, we assume that we have an incomplete description of the initial state, since we only know it satisfies a given precondition, but have no concrete interpretation.

The first of such problems is to ‘certify’ that a candidate plan is indeed a plan for the goal, for every possible database satisfying the precondition.

  1. Given a sequence of actions and formulae , , is a plan for from every finite interpretation with , for every possible substitution ?

Finally, we are interested in the existence of a plan that always achieves the goal, for every possible state satisfying the precondition. Solving this problem corresponds to the automated synthesis of a program for reaching a certain condition. We formulate the problem with and without a bound on the length of the plans we are looking for.

  1. Given a set of actions and formulae , , does there exist a sequence of actions such that is a plan for from every finite interpretation with ), for every possible substitution ?

  2. Given a set of actions, formulae , and a positive integer , does there exist a sequence of actions such that is of length at most and is a plan for from every finite interpretation with , for every possible substitution ?

We conclude with the complexity of these problems:

Theorem 11.

The following hold:

  1. Problem (S) is undecidable, already for KBs and simple actions.

  2. Problems (C) and (Sb) are co-complete.

  3. If are expressed in and all actions in are simple, then (C) is co-complete and (Sb) is -complete.

7 Related Work

Using DLs to understand the properties of systems while fully taking into account both structural and dynamic aspects is very challenging [36]. Reasoning in DLs extended with a temporal dimension becomes quickly undecidable [2], unless severe restrictions on the expressive power of the DL are imposed [4]. An alternative approach to achieve decidability is to take a so-called “functional view of KBs” [28], according to which each state of the KB can be queried via logical implication, and the KB is progressed from one state to the next through forms of update [17]. This makes it possible (under suitable conditions) to statically verify (temporal) integrity constraints over the evolution of a system [6, 10].

Updating databases, and logic theories in general, is a classic topic in knowledge representation, discussed extensively in the literature, cf. [21, 23]. The updates described by our action language are similar in spirit to the knowledge base updates studied in other works, and in particular, the ABox updates considered in [29], and [24]. As our updates are done directly on interpretations rather than on (the instance level of) knowledge bases, we do not encounter the expressibility and succinctness problems faced there.

Concerning the reasoning problems we tackle, verifying consistency of transactions is a crucial problem that has been studied extensively in Databases. It has been considered for different kinds of transactions and constraints, over traditional relational databases [33], object-oriented databases [34, 12], and deductive databases [25], to name a few. Most of these works adopt expressive formalisms like (extensions of) first or higher order predicate logic [12], or undecidable tailored languages [33] to express the constraints and the operations on the data. Verification systems are often implemented using theorem provers, and complete algorithms cannot be devised.

As mentioned, the problems studied in Section 6 are closely related to automated planning, a topic extensively studied in AI. DLs have been employed to reason about actions, goals, and plans, as well as about the application domains in which planning is deployed, see [22] and its references. Most relevant to us is the significant body of work on DL-based action languages [8, 30, 7, 29, 9]. In these formalisms, DL constructs are used to give conditions on the effects of action execution, which are often non-deterministic. A central problem considered is the projection problem, which consists in deciding whether every possible execution of an action sequence on a possibly incomplete state will lead to a state that satisfies a given property. Clearly, our certification problem (C), which involves an incomplete initial state, is a variation of the projection problem. However, we do not face the challenge of having to consider different possible executions of non-deterministic actions. Many of our other reasoning problems are similar to problems considered in these works, in different forms and contexts. A crucial difference is that our well-behaved action language allows us to obtain decidability even when we employ full-fledged TBoxes for specifying goals, preconditions, and domain constraints. To the best of our knowledge, previous results rely on TBox acyclicity to ensure decidability.

8 Conclusions

We have considered graph structured data that evolve as a result of updates expressed in a powerful yet well-behaved action language. We have studied several reasoning problems that support the static analysis of actions and their effects on the state of the data. We have shown the decidability of most problems, and in the cases where the general problem is undecidable, we have identified decidable restrictions and have characterized the computational complexity for a very expressive DL and a variant of . We believe this work provides powerful tools for analyzing the effects of executing complex actions on databases, possibly in the presence of integrity constraints expressed in rich DLs. Our upper bounds rely on a novel KB transformation technique, which enables to reduce most of the reasoning tasks to finite (un)satisfiability in a DL. This calls for developing finite model reasoners for DLs (we note that does not have the finite model property). It also remains to better understand the complexity of finite model reasoning in different variations of . E.g., extensions of with role functionality would be very useful in the context of graph structured data. Generalizing the positive decidability results to logics with powerful identification constraints, like the ones considered in [18], would also be of practical importance. Given that the considered problems are intractable even for weak fragments of the core and very restricted forms of actions, it remains to explore how feasible these tasks are in practice, and whether there are meaningful restrictions that make them tractable.

Acknowledgments

This research has been partially supported by FWF projects T515-N23 and P25518-N23, by WWTF project ICT12-015, by EU IP Project Optique FP7-318338, and by the Wolfgang Pauli Institute.

References

  • [1] Shqiponja Ahmetaj, Diego Calvanese, Magdalena Ortiz, and Mantas Šimkus. Managing change in Graph-structured Data using Description Logics. In Proc. of AAAI 2014, 2014.
  • [2] Alessandro Artale. Reasoning on temporal class diagrams: Undecidability results. AMAI, 46(3):265–288, 2006.
  • [3] Alessandro Artale, Diego Calvanese, Roman Kontchakov, Vladislav Ryzhikov, and Michael Zakharyaschev. Reasoning over extended ER models. In Proc. of ER, volume 4801 of LNCS, pages 277–292. Springer, 2007.
  • [4] Alessandro Artale, Roman Kontchakov, Vladislav Ryzhikov, and Michael Zakharyaschev. Tailoring temporal description logics for reasoning over temporal conceptual models. In Proc. of FroCoS, pages 1–11. Springer, 2011.
  • [5] Franz Baader, Diego Calvanese, Deborah McGuinness, Daniele Nardi, and Peter F. Patel-Schneider, editors. The Description Logic Handbook: Theory, Implementation and Applications. Cambridge University Press, 2003.
  • [6] Franz Baader, Silvio Ghilardi, and Carsten Lutz. LTL over description logic axioms. ACM TOCL, 13(3):21:1–21:32, 2012.
  • [7] Franz Baader, Marcel Lippmann, and Hongkai Liu. Using causal relationships to deal with the ramification problem in action formalisms based on description logics. In Proc. of LPAR 17, volume 6397 of LNCS, pages 82–96. Springer, 2010.
  • [8] Franz Baader, Carsten Lutz, Maja Milicic, Ulrike Sattler, and Frank Wolter. Integrating description logics and action formalisms: First results. In Proc. of AAAI, pages 572–577, 2005.
  • [9] Franz Baader and Benjamin Zarrie. Verification of Golog programs over description logic actions. In Proc. of FroCoS, volume 8152 of LNCS, pages 181–196. Springer, 2013.
  • [10] Babak Bagheri Hariri, Diego Calvanese, Marco Montali, Giuseppe De Giacomo, Riccardo De Masellis, and Paolo Felli. Description logic Knowledge and Action Bases. JAIR, 46:651–686, 2013.
  • [11] Daniela Berardi, Diego Calvanese, and Giuseppe De Giacomo. Reasoning on UML class diagrams. AIJ, 168(1–2):70–118, 2005.
  • [12] Anthony J. Bonner and Michael Kifer. An overview of Transaction Logic. TCS, 133(2):205–265, 1994.
  • [13] Alex Borgida. On the relative expressiveness of description logics and predicate logics. AIJ, 82(1–2):353–367, 1996.
  • [14] Dan Brickley and R. V. Guha. RDF vocabulary description language 1.0: RDF Schema. W3C Recommendation, W3C, February 2004. Available at http://www.w3.org/TR/rdf-schema/.
  • [15] Tom Bylander. The computational complexity of propositional STRIPS planning. AIJ, 69:165–204, 1994.
  • [16] Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, and Riccardo Rosati. Tractable reasoning and efficient query answering in description logics: The DL-Lite family. JAR, 39(3):385–429, 2007.
  • [17] Diego Calvanese, Giuseppe De Giacomo, Maurizio Lenzerini, and Riccardo Rosati. Actions and programs over description logic knowledge bases: A functional approach. In Knowing, Reasoning, and Acting: Essays in Honour of Hector Levesque. College Publications, 2011.
  • [18] Diego Calvanese, Wolfgang Fischl, Reinhard Pichler, Emanuel Sallinger, and Mantas Šimkus. Capturing relational schemas and functional dependencies in rdfs. In Proc. of AAAI 2014, 2014.
  • [19] Diego Calvanese, Magdalena Ortiz, and Mantas Šimkus. Evolving graph databases under description logic constraints. In Proc. of DL, volume 1014 of CEUR Workshop Proceedings, pages 120–131, 2013.
  • [20] Mariano P. Consens and Alberto O. Mendelzon. GraphLog: a visual formalism for real life recursion. In Proc. of PODS, pages 404–416, 1990.
  • [21] Ronald Fagin, Gabriel M. Kuper, Jeffrey D. Ullman, and Moshe Y. Vardi. Updating logical databases. In Advances in Computing Research, pages 1–18. JAI Press, 1986.
  • [22] Yolanda Gil. Description logics and planning. AI Magazine, 26(2):73–84, 2005.
  • [23] Hirofumi Katsuno and Alberto O. Mendelzon. On the difference between updating a knowledge base and revising it. In Proc. of KR, pages 387–394, 1991.
  • [24] Evgeny Kharlamov, Dmitriy Zheleznyakov, and Diego Calvanese. Capturing model-based ontology evolution at the instance level: The case of DL-Lite. JCSS, 79(6):835–872, 2013.
  • [25] Robert A. Kowalski, Fariba Sadri, and Paul Soper. Integrity checking in deductive databases. In Proc. of VLDB, pages 61–69, 1987.
  • [26] Maurizio Lenzerini. Ontology-based data management. In Proc. of CIKM, pages 5–6, 2011.
  • [27] H. J. Levesque, R. Reiter, Y. Lesperance, F. Lin, and R. Scherl.

    GOLOG: A logic programming language for dynamic domains.

    JLP, 31:59–84, 1997.
  • [28] Hector J. Levesque. Foundations of a functional approach to knowledge representation. AIJ, 23:155–212, 1984.
  • [29] Hongkai Liu, Carsten Lutz, Maja Milicic, and Frank Wolter. Foundations of instance level updates in expressive description logics. AIJ, 175(18):2170–2197, 2011.
  • [30] Maja Milicic. Action, Time and Space in Description Logics. PhD thesis, TU Dresden, 2008.
  • [31] Ian Pratt-Hartmann. Complexity of the two-variable fragment with counting quantifiers. JLLI, 14(3):369–395, 2005.
  • [32] Sherif Sakr and Eric Pardede, editors. Graph Data Management: Techniques and Applications. IGI Global, 2011.
  • [33] Tim Sheard and David Stemple. Automatic verification of database transaction safety. ACM TODS, 14(3):322–368, 1989.
  • [34] D. Spelt and H. Balsters. Automatic verification of transactions on an object-oriented database. In Proc. of DBPL, volume 1369 of LNCS, pages 396–412. Springer, 1998.
  • [35] Stephan Tobies. The complexity of reasoning with cardinality restrictions and nominals in expressive description logics. JAIR, 12:199–217, 2000.
  • [36] Frank Wolter and Michael Zakharyaschev. Temporalizing description logic. In D. Gabbay and M. de Rijke, editors, Frontiers of Combining Systems, pages 379–402. Studies Press/Wiley, 1999.

Appendix

Proof of Theorem 3.

(i) to (ii). Assume there exist a ground instance of and a finite interpretation such that and . Then by Theorem 2, . Thus . Suppose is the substitution that transforms into . Suppose also is the substitution that transforms into . Take the interpretation that coincides with except for . Then .

(ii) to (i). Assume is finitely satisfiable, i.e., there is an interpretation such that and . Then by Theorem 2, . ∎

Proof of Theorem 4.

For co-hardness, we note that finite unsatisfiability of KBs can be reduced in polynomial time to static verification in the presence of KBs. Indeed, a KB is finitely satisfiable iff is not -preserving, where , are fresh concept names and is a fresh individual.

[MO] Obtaining a matching upper bound is slightly more involved. It follows from Theorem 3 that the complement of static verification in the presence of KBs reduces to finite satisfiability of a KB in , but unfortunately, this reduction is exponential in general. Hence we use an alternative reduction that allow us to non-deterministically build in polynomial time a formula of polynomial size, such that is satisfiable iff is satisfiable. The upper bound then follows from this and the fact that finite satisfiability in is -complete (c.f. Theorem 1). 11todo: 1the rest of the proof is new

To obtain this non-deterministic polynomial time many-one reduction, it is convenient to first define a minor variation of the transformation above, which generates an already negated KB.