Temporal Query Answering in DL-Lite

Abstract

Context-aware applications try to detect specific situations within a changing environment (e.g. a computer system or air traffic observed by radar) in order to react accordingly. To gain information, the environment is observed by sensors (for a computer system, data about its resources is gathered by the operating system), and the results of sensing are stored in a database. A context-aware application then detects specific predefined situations based on this data (e.g. a high system load) and executes some action (e.g. increases the CPU frequency). In a simple setting, such an application can be realized by using standard database techniques: the sensor information is stored in a database, and the situations to be recognized are specified as database queries [1]. However, we cannot assume that the sensors provide a complete description of the current state of the environment. Thus, the closed world assumption employed by database systems (i.e. facts not present in the database are assumed to be false) is not appropriate since there may be facts of which the truth is not known. For example, a sensor for certain information might not be available for a moment or not even exist. In addition, though a complete specification of the environment usually does not exist, often some knowledge about its behavior is available. This knowledge can be used to formulate constraints on the interpretation of the predicates used in the queries, to detect more complex situations. In ontology-based data access (OBDA) [8], domain knowledge is encoded in ontologies using a description logic (DL). In this paper, we consider logics of the DL-Lite family, which are lightweight DLs with a low complexity for many reasoning problems [8]. In order to recognize situations that evolve over time, we propose to add a temporal logical component to the queries. We use the operators of the temporal logic LTL, which allows to reason about a linear and discrete flow of time [17]. Usual temporal operators include next (#φ), eventually (3φ), and always (2φ), asserting that a property φ is true at the next point in time, at some point in the future, and at all time points in the future, respectively. We also use the corresponding past operators #−, 3−, and 2−. Consider, for example, a collection of servers providing several services. An important task is to migrate services between servers to balance the load. To decide when to migrate, we want to detect certain critical situations. We consider a process to be critical if it has an increasing workload, and at the same time the

View Slides

Extracted Key Phrases

Cite this paper

@inproceedings{Borgwardt2013TemporalQA, title={Temporal Query Answering in DL-Lite}, author={Stefan Borgwardt and Marcel Lippmann and Veronika Thost}, booktitle={Description Logics}, year={2013} }