Classical Algorithms for Reasoning and Explanation in Description Logics

Abstract

Description Logics (DLs) are a family of languages designed to represent conceptual knowledge in a formal way as a set of ontological axioms. DLs provide a formal foundation of the ontology language OWL, which is a W3C standardized language to represent information in Web applications. The main computational problem in DLs is finding relevant consequences of the information stored in ontologies, e.g., to answer user queries. Unlike related techniques based on keyword search or machine learning, the notion of a consequence is well-defined using a formal logic-based semantics. This course provides an in-depth description and analysis of the main reasoning and explanation methods for ontologies: tableau procedures and axiom pinpointing algorithms.

A Appendix

For the convenience of interested readers, in this appendix we recap some background material used in this course, such as the basic notions for describing the (theoretical) complexity of algorithms, and the propositional satisfiability problem.

1.1 A.1 Computational Complexity

A decision problem (for an input set X) is simply a mapping $P :X \rightarrow \{\textit{yes}, \textit{no}\}$. Note that X can be an arbitrary set of objects. For example, for the concept subsumption problem, X consists of all possible pairs $\langle {\mathcal {O},C\sqsubseteq D}\rangle$ where the first component is an ontology $\mathcal {O}$ and the second component is a concept subsumption $C\sqsubseteq D$. An algorithm A solves (or decides) a decision problem P for X, if A accepts each value $x\in X$ as input, terminates for all these values, and returns the (correct) result $A(x)=P(x)$.

There are several dimensions according to which one can measure the computational complexity of problems and algorithms. We say that an algorithm A has an (upper) time complexity f(n) if for each input $x\in X$ with the size (e.g., the number of symbols) n, the algorithm A terminates after at most f(n) steps. A problem P for X is solvable in time f(n) if there exists an algorithm A that solves P and has the time complexity f(n). We say that a problem P is solvable in polynomial time if there exists a polynomial function f(n) such that P is solvable in time f(n). A problem P is solvable in exponential time (doubly exponential time, ...) if there exists a polynomial function f(n) such that P is solvable in time $2^{f(n)}$ ($2^{2^{f(n)}}$, ...). Analogously to the algorithmic time complexity, one can define the algorithmic space complexity: a problem P for X is solvable in space f(n) if there exists an algorithm A that solves P such that for each input $x\in X$ with the size n, the algorithm A uses at most f(n) units of memory at every step of the computation.

Another dimension of the computational complexity is based on the notion of a non-deterministic computation. An algorithm A is said to be non-deterministic if the result of some operations that it can perform is not uniquely determined. Thus, the algorithm can produce different results for different runs even with the same input. A non-deterministic algorithm A solves a problem P for X if, for each $x\in X$ such that $P(x)=\textit{no}$, each run of A terminates with the result $\textit{no}$, and for each $x\in X$ such that $P(x)=\textit{yes}$, there exists at least one run for which the algorithm terminates and produces $\textit{yes}$. The intuition is that, if one has an unlimited number of identical computers, then one can solve the problem P by starting the algorithm A in parallel on all of these computers; if $P(x)=\textit{yes}$, one of them is guaranteed to return $\textit{yes}$ (provided the results of all non-deterministic instructions are chosen at random).

The time and space complexity measures are also extended to non-deterministic algorithms. For example, a non-deterministic algorithm A has the (upper) time complexity f(n) if, for every input $x\in X$ of the size n, every run of A terminates after at most f(n) steps. We say that a problem P for X is solvable in non-deterministic time f(n) if there exists a non-deterministic algorithm A that solves P and has the time complexity f(n). Thus, a problem P is solvable in non-deterministic polynomial (exponential, doubly exponential, ...) time if P is solvable in non-deterministic time f(n), where f(n) is a polynomial (exponential, doubly exponential) function. The non-deterministic space complexity is defined similarly.

A common way to solve a problem is to reduce it to another problem, for which a solution is known. A decision problem $P_1 :X \rightarrow \{\textit{yes}, \textit{no}\}$ is (many-one) reducible to a decision problem $P_2 :Y \rightarrow \{\textit{yes}, \textit{no}\}$ if there exists an algorithm $R :X \rightarrow Y$ (that takes an input from X and produces an output from Y) such that for every $x\in X$, we have $P_1(x)=P_2(R(x))$. In this case the algorithm R is called a reduction from $P_1$ to $P_2$. Depending on the time or space complexity of the algorithm R (i.e., the maximal number of steps or memory units consumed for inputs of size n), the complexity bounds of the problems are also transferred by the reduction. Usually one is interested in polynomial reductions, where the number of steps for computing each R(x) is bounded by a polynomial function in the size of x. In this case, if the complexity of $P_2$ is polynomial, exponential, or doubly exponential (for deterministic or non-deterministic, time or space complexity), then $P_1$ has the same complexity as $P_2$.

1.2 A.2 Propositional Logic and SAT

The vocabulary of Propositional Logic consists of a countably infinite set P of propositional variables, Boolean constants: $\top$ (Verum), $\bot$ (Falsum), and Boolean operators: $\wedge$ (conjunction), $\vee$ (disjunction), $\lnot$ (negation) and $\rightarrow$ (implication). Propositional formulas are constructed from these symbols according to the grammar:

$$\begin{aligned} F,G \,{::=} \,p \mid \top \mid \bot \mid F \wedge G \mid F \vee G \mid \lnot F \mid F\rightarrow G, \end{aligned}$$

(10)

where $p\in P$. A propositional interpretation $\mathcal {I}$ assigns to each propositional variable $p\in P$ a truth value $p^\mathcal {I}\in \{1,0\}$ (1 means ‘true’, 0 means ‘false’) and is extended to other propositional formulas by induction over the grammar definition (10) as follows:

• $\top ^\mathcal {I}=1$ and $\bot ^\mathcal {I}=0$ for each $\mathcal {I}$,

• $(F\wedge G)^\mathcal {I}=1$ if and only if $F^\mathcal {I}=1$ and $G^\mathcal {I}=1$,

• $(F\vee G)^\mathcal {I}=1$ if and only if $F^\mathcal {I}=1$ or $G^\mathcal {I}=1$,

• $(\lnot F)^\mathcal {I}=1$ if and only if $F^\mathcal {I}=0$,

• $(F\rightarrow G)^\mathcal {I}=1$ if and only if $F^\mathcal {I}=0$ or $G^\mathcal {I}=1$.

If $F^\mathcal {I}=1$ then we say that $\mathcal {I}$ is a model of F (or F is satisfied in $\mathcal {I}$). We say that F is satisfiable if F has at least one model; otherwise F is unsatisfiable. A propositional satisfiability problem (short: SAT) is the following decision problem:

• Given: a propositional formula F,

• Return: yes if F is satisfiable and no otherwise.

SAT is a classical example of a non-deterministic polynomial (short: NP) problem: it can be solved using an algorithm that non-deterministically choses a propositional interpretation $\mathcal {I}$, computes (in polynomial time) the value $F^\mathcal {I}$ and returns $yes$ if $F^\mathcal {I}=1$ and $no$ if $F^\mathcal {I}=0$. It can be shown that each problem solvable by a non-deterministic polynomial algorithm has a polynomial reduction to SAT, which means that SAT is actually an NP-complete problem. Currently, the most efficient algorithms for solving SAT are based on (extensions of) the Davis-Putnam-Logemann-Loveland (short: DPLL) procedure, which systematically explores interpretations in a goal-directed way. A program that implements an algorithm for solving SAT is called a SAT-solver. Usually a SAT-solver not only decides satisfiability of a given propositional formula F, but can also output a model of F in case F is satisfiable.