Algorithmic definitions for KLM-style defeasible disjunctive Datalog

In this work we study a rational extension $SROEL^R T$ of the low complexity description logic SROEL, which underlies the OWL EL ontology language. The extension involves a typicality operator T, whose semantics is based on Lehmann and Magidor's ranked models and allows for the definition of defeasible inclusions. We consider both rational entailment and minimal entailment. We show that deciding instance checking under minimal entailment is in general $\Pi^P_2$-hard, while, under rational entailment, instance checking can be computed in polynomial time. We develop a Datalog calculus for instance checking under rational entailment and exploit it, with stratified negation, for computing the rational closure of simple KBs in polynomial time.

Defeasible reasoning is a rule-based approach for efficient reasoning with incomplete and inconsistent information. Such reasoning is, among others, useful for ontology integration, where conflicting information arises naturally; and for the modeling of business rules and policies, where rules with exceptions are often used. This paper describes these scenarios in more detail, and reports on the implementation of a system for defeasible reasoning on the Web. The system is called DR-DEVICE and is capable of reasoning about RDF metadata over multiple Web sources using defeasible logic rules. The system is implemented on top of CLIPS production rule system and builds upon R-DEVICE, an earlier deductive rule system over RDF metadata that also supports derived attribute and aggregate attribute rules. Rules can be expressed either in a native CLIPS-like language, or in an extension of the OO-RuleML syntax. The operational semantics of defeasible logic are implemented through compilation into the generic rule language of R-DEVICE. The paper also briefly presents a semantic web broker example for apartment renting.

Recent technological advances have led to unprecedented amounts of generated data that originate from the Web, sensor networks, and social media. Analytics in terms of defeasible reasoning – for example, for decision making – could provide richer knowledge of the underlying domain. Traditionally, defeasible reasoning has focused on complex knowledge structures over small to medium amounts of data, but recent research efforts have attempted to parallelize the reasoning process over theories with large numbers of facts. Such work has shown that traditional defeasible logics come with overheads that limit scalability. In this work, we design a new logic for defeasible reasoning, thus ensuring scalability by design. We establish several properties of the logic, including its relation to existing defeasible logics. Our experimental results indicate that our approach is indeed scalable and defeasible reasoning can be applied to billions of facts.

SummaryNetwork function virtualization (NFV) allows to model network services as graphs interconnecting virtual network functions (VNFs), which may include nested VNFs, modeled as subgraphs of VNFs or end points. To query the performance data of network services modeled as abstract and high‐level graphs is challenging because of the recursivity of the NFV architecture and the elasticity and dynamicity provided by the NFV infrastructure. We propose to use Datalog, a declarative logic programming language, to build a framework that supports efficient data aggregation for performance metrics of recursively modeled network services. We present our recursive query language for automatic and flexible decomposition and aggregation of NFV performance metrics and describe example use cases for both compute and network metrics. We also describe the design and implementation of a proof‐of‐concept query engine using the language. Our performance evaluation shows that the total query latency is dominated by retrieval times of performance metrics from infrastructure databases, and the time for execution and automatic decomposition of high‐level queries by the query engine itself increases linearly with the size of the service graph up to 1000 nodes. Hence, our evaluations show that the query engine scales well, bounded mainly by the limited execution capabilities of our test environment. Furthermore, it can handle multiple concurrent queries up to the concurrency limits of the backend database in use. The proposed query language and engine are thus effective in recursively retrieving performance metrics of NFV environments supporting large‐scale service graphs and large numbers of query requests.

In this thesis we study KLM-style rational reasoning in defeasible Description Logics. We illustrate that many recent approaches to derive consequences under Rational Closure (and its stronger variants, lexicographic and relevant closure) suffer the fatal drawback of neglecting defeasible information in quantified concepts. We propose novel model-theoretic semantics that are able to derive the missing entailments in two differently strong flavours. Our solution introduces a preference relation to distinguish sets of models in terms of their typicality (amount of defeasible information derivable for quantified concepts). The semantics defined through the most typical (most preferred) sets of models are proven superior to previous approaches in that their entailments properly extend previously derivable consequences, in particular, allowing to derive defeasible consequences for quantified concepts. The dissertation concludes with an algorithmic characterisation of this uniform maximisation of typicality, which accompanies our investigation of the computational complexity for deriving consequences under these new semantics.

Defeasible reasoning is a rule-based approach for efficient reasoning with incomplete and inconsistent information. Such reasoning is useful for many applications in the Semantic Web, such as policies and business rules, agent brokering and negotiation, ontology and knowledge merging, etc. However, the syntax of defeasible logic may appear too complex for many users. In this paper we present a graphical authoring tool for defeasible logic rules that acts as a shell for the DR-DEVICE defeasible reasoning system over RDF metadata. The tool helps users to develop a rule base using the OO-RuleML syntax of DR-DEVICE rules, by constraining the allowed vocabulary through analysis of the input RDF namespaces, so that the user does not have to type-in class and property names. Rule visualization follows the tree model of RuleML. The DR-DEVICE reasoning system is implemented on top of the CLIPS production rule system and builds upon an earlier deductive rule system over RDF metadata that also supports derived attribute and aggregate attribute rules.

Our purpose is to develop a modular systematic method of representing nonmonotonic reasoning problems with the Well Founded Semantics of extended logic programs augmented with eXplicit negation (WFSX), and augmented by its Contradiction Removal Semantics (CRSX) when needed. We show how to cast in the language of such logic programs forms of non-monotonic reasoning like defeasible reasoning and hypothetical reasoning, and apply them to different domains of knowledge representation, for instance taxonomic hierarchies and reasoning about actions. We then abstract a modular systematic method of representing non-monotonic problems in logic programming.

Extending Defeasible Reasoning Beyond Rational Closure

EVID: A system for interactive defeasible reasoning

The “fuzzy dot” (or fuzzy relation) representation of fuzzy rules in fuzzy rule based systems, in case of classical fuzzy reasoning methods (e.g. the Zadeh-Mamdani- Larsen Compositional Rule of Inference (CRI) (Zadeh, 1973) (Mamdani, 1975) (Larsen, 1980) or the Takagi - Sugeno fuzzy inference (Sugeno, 1985) (Takagi & Sugeno, 1985)), are assuming the completeness of the fuzzy rule base. If there are some rules missing i.e. the rule base is “sparse”, observations may exist which hit no rule in the rule base and therefore no conclusion can be obtained. One way of handling the “fuzzy dot” knowledge representation in case of sparse fuzzy rule bases is the application of the Fuzzy Rule Interpolation (FRI) methods, where the derivable rules are deliberately missing. Since FRI methods can provide reasonable (interpolated) conclusions even if none of the existing rules fires under the current observation. From the beginning of 1990s numerous FRI methods have been proposed. The main goal of this article is to give a brief but comprehensive introduction to the existing FRI methods.

Defeasible reasoning is a rule-based approach for efficient reasoning with incomplete and inconsistent information. Such reasoning is, among others, useful for ontology integration, where conflicting information arises naturally; and for the modeling of business rules and policies, where rules with exceptions are often used. This paper describes these scenarios and reports on the implementation of a system for defeasible reasoning on the Web. The system, DR-DEVICE, is capable of reasoning about RDF metadata over multiple Web sources using defeasible logic rules. It is implemented on top of CLIPS production rule system and builds upon R-DEVICE, an earlier deductive rule system over RDF metadata that also supports derived attribute and aggregate attribute rules. Rules can be expressed either in a native CLIPS-like language, or in an extension of the OO-RuleML syntax. The operational semantics of defeasible logic are implemented through compilation into the generic rule language of R-DEVICE. The paper also presents a full semantic Web broker example for apartment renting.

Extended logic programs allow for negative conclusions in rules. So, the question of how to deal with contradictions arises. The trivialization (or ‘explosion’) approach of classical logic, according to which everything follows from a contradiction, is certainly not adequate for the purpose of processing partially inconsistent information in a cognitively and computationally satisfactory way. We propose to consider logical principles instead, which stem from the area of directly skeptical inheritance, or defeasible reasoning, known from the AI literature on nonmonotonic reasoning. In these systems conflicting pieces of information neutralize each other unless one of them ‘preempts’ (i.e. defeats) the other. The preemption mechanism is usually based on some notion of specificity. Extending earlier work [19], where we have introduced the concept of neutralization to the framework of extended logic programs, we show in this paper how to add a general mechanism for specificity-based preemption and demonstrate its feasibility by presenting an appropriate meta-interpreter.

Deploying defeasible logic rule bases for the semantic web

In most fuzzy systems, the completeness of the fuzzy rule base is required to generate meaningful output when classical fuzzy reasoning methods are applied. This means, in other words, that the fuzzy rule base has to cover all possible inputs. Regardless of the way of rule base construction, be it created by human experts or by an automated manner, often incomplete rule bases are generated. One simple solution to handle sparse fuzzy rule bases and to make infer reasonable output is the application of fuzzy rule interpolation (FRI) methods. In this paper, we present a Fuzzy Rule Interpolation Matlab Toolbox, which is freely available. With the introduction of this Matlab Toolbox, different FRI methods can be used for different real time applications, which have sparse or incomplete fuzzy rule base.

Datalog is a popular and widely-used declarative logic programming language. Datalog engines apply many cross-rule optimizations; bugs in them can cause incorrect results. To detect such optimization bugs, we propose an automated testing approach called Incremental Rule Evaluation (IRE), which synergistically tackles the test oracle and test case generation problem. The core idea behind the test oracle is to compare the results of an optimized program and a program without cross-rule optimization; any difference indicates a bug in the Datalog engine. Our core insight is that, for an optimized, incrementally-generated Datalog program, we can evaluate all rules individually by constructing a reference program to disable the optimizations that are performed among multiple rules. Incrementally generating test cases not only allows us to apply the test oracle for every new rule generated—we also can ensure that every newly added rule generates a non-empty result with a given probability and eschew recomputing already-known facts. We implemented IRE as a tool named Deopt, and evaluated Deopt on four mature Datalog engines, namely Soufflé, CozoDB, μZ, and DDlog, and discovered a total of 30 bugs. Of these, 13 were logic bugs, while the remaining were crash and error bugs. Deopt can detect all bugs found by queryFuzz, a state-of-the-art approach. Out of the bugs identified by Deopt, queryFuzz might be unable to detect 5. Our incremental test case generation approach is efficient; for example, for test cases containing 60 rules, our incremental approach can produce 1.17× (for DDlog) to 31.02× (for Soufflé) as many valid test cases with non-empty results as the naive random method. We believe that the simplicity and the generality of the approach will lead to its wide adoption in practice.