Logic-based Knowledge Representation Research Articles

Extending the description logic [formula omitted] with threshold concepts induced by concept measures

In applications of AI systems where exact definitions of the important notions of the application domain are hard to come by, the use of traditional logic-based knowledge representation languages such as Description Logics may lead to very large and unintuitive definitions, and high complexity of reasoning. To overcome this problem, we define new concept constructors that allow us to define concepts in an approximate way. To be more precise, we present a family τEL(m) of extensions of the lightweight Description Logic EL that use threshold constructors for this purpose. To define the semantics of these constructors we employ graded membership functions m, which for each individual in an interpretation and concept yield a number in the interval [0,1] expressing the degree to which the individual belongs to the concept in the interpretation. Threshold concepts C⋈t for ⋈∈{<,≤,>,≥} then collect all the individuals that belong to C with degree ⋈t. The logic τEL(m) extends EL with threshold concepts whose semantics is defined relative to a function m. To construct appropriate graded membership functions, we show how concept measures ∼ (which are graded generalizations of subsumption or equivalence between concepts) can be used to define graded membership functions m∼. Then we introduce a large class of concept measures, called simi-d, for which the logics τEL(m∼) have good algorithmic properties. Basically, we show that reasoning in τEL(m∼) is NP/coNP-complete without TBox, PSpace-complete w.r.t. acyclic TBoxes, and ExpTime-complete w.r.t. general TBoxes. The exception is the instance problem, which is already PSpace-complete without TBox w.r.t. combined complexity. While the upper bounds hold for all elements of simi-d, we could prove some of the hardness results only for a subclass of simi-d. This article considerably improves on and generalizes results we have shown in three previous conference papers and it provides detailed proofs of all our results.

General Knowledge Representation and Sharing, with Illustrations in Risk/Emergency Management

Many decision-making tasks, including the sustainability-oriented ones and those related to the management of risks or emergencies, must gather, integrate, and analyze an important amount of information of various kinds and origins. Hence, how should information be best organized and shared by agents – people or software – for all and only the pieces of information looked for by these agents to be maximize their retrieval, reuse, organization and analysis by these agents? To that end, various logic-based knowledge representation (KR) and sharing (KS) techniques, and hence KR bases, have been used. However, most KS researchers focus on what this article defines as “restricted KR and KS”, where information providers and consumers can or have to discuss for solving information ambiguities and other problems. The first part of this article highlights the usefulness of “general KR and KS” and, for supporting them, provides a panorama of complementary techniques, and hence, indirectly, best practices or kinds of tools to use for general KS purposes. These techniques collectively answer research questions about how to support Web users in the collaborative building of KR bases. The second part uses the risk/emergency management domain to illustrate the ways different types of information can be represented to support general KS.

The Price of Selfishness: Conjunctive Query Entailment for ALCSelf Is 2EXPTIME-Hard

In logic-based knowledge representation, query answering has essentially replaced mere satisfiability checking as the inferencing problem of primary interest. For knowledge bases in the basic description logic ALC, the computational complexity of conjunctive query (CQ) answering is well known to be EXPTIME-complete and hence not harder than satisfiability. This does not change when the logic is extended by certain features (such as counting or role hierarchies), whereas adding others (inverses, nominals or transitivity together with role-hierarchies) turns CQ answering exponentially harder. We contribute to this line of results by showing the surprising fact that even extending ALC by just the Self operator – which proved innocuous in many other contexts – increases the complexity of CQ entailment to 2EXPTIME. As common for this type of problem, our proof establishes a reduction from alternating Turing machines running in exponential space, but several novel ideas and encoding tricks are required to make the approach work in that specific, restricted setting.

Finite Entailment of Local Queries in the Z Family of Description Logics

In the last few years the field of logic-based knowledge representation took a lot of inspiration from database theory. A vital example is that the finite model semantics in description logics (DLs) is reconsidered as a desirable alternative to the classical one and that query entailment has replaced knowledge-base satisfiability (KBSat) checking as the key inference problem. However, despite the considerable effort, the overall picture concerning finite query answering in DLs is still incomplete. In this work we study the complexity of finite entailment of local queries (conjunctive queries and positive boolean combinations thereof) in the Z family of DLs, one of the most powerful KR formalisms, lying on the verge of decidability. Our main result is that the DLs ZOQ and ZOI are finitely controllable, i.e. that their finite and unrestricted entailment problems for local queries coincide. This allows us to reuse recently established upper bounds on querying these logics under the classical semantics. While we will not solve finite query entailment for the third main logic in the Z family, ZIQ, we provide a generic reduction from the finite entail- ment problem to the finite KBSat problem, working for ZIQ and some of its sublogics. Our proofs unify and solidify previously established results on finite satisfiability and finite query entailment for many known DLs.

A Brief Roadmap into Uncertain Knowledge Representation via Probabilistic Description Logics

Logic-based knowledge representation is one of the main building blocks of (logic-based) artificial intelligence. While most successful knowledge representation languages are based on classical logic, realistic intelligent applications need to handle uncertainty in an adequate manner. Over the years, many different languages for representing uncertain knowledge—often extensions of classical knowledge representation languages—have been proposed. We briefly present some of the defining properties of these languages as they pertain to the family of probabilistic description logics. This limited view is intended to help pave the way for the interested researcher to find the most adequate language for their needs, and potentially identify the remaining gaps.

Adding Metalogic Features to Knowledge Representation Languages*

In this paper we present a methodology for introducing customizable metalogic features in logic-based knowledge representation and reasoning languages. The proposed approach is based on concepts of introspection and reflection previously introduced and discussed by various authors in relevant literature. This allows a knowledge engineer to specify enhanced reasoning engines by defining properties and meta-properties of relations as expressible for instance in OWL. We employ meta-level axiom schemata based upon a naming (reification) device. We propose general principles for extending the semantics of “host” formalisms accordingly. Consequently, suitable pre-defined libraries of properties can be made available, while user-defined new schemata are also allowed. We make the specific cases of Answer Set Programming (ASP) and Datalog±, where such features may be part of software engineering toolkits for these programming paradigms. On the one hand, concerning ASP, we extend the programming principles and practice to accommodate the proposed methodology, so as to perform meta-reasoning within the plain ASP semantics. The computational complexity of the resulting framework does not change. On the other hand, we show how metalogic features can significantly enrich Datalog± with minor changes to its operational semantics (provided in terms of “chase”) and, also in this case, no additional complexity burden.

Testing Multi-Threaded Applications Using Answer Set Programming

We introduce a technique to formally represent and specify race conditions in multithreaded applications. Answer set programming (ASP) is a logic-based knowledge representation paradigm to formally express belief acquired through reasoning in an application domain. The transparent and expressiveness representation of problems along with powerful non-monotonic reasoning power enable ASP to abstractly represent and solve some certain classes of NP hard problems in polynomial times. We use ASP to formally express race conditions and thus represent potential data races often occurred in multithreaded applications with shared memory models. We then use ASP to generate all possible test inputs and thread interleaving, i.e. scheduling, whose executions would result in deterministically exposing thread interleaving failures. We evaluated the proposed technique with some moderate sized Java programs, and our experimental results confirm that the proposed technique can practically expose common data races in multithreaded programs with low false positive rates. We conjecture that, in addition to generating threads scheduling whose execution order leads to the exposition of data races, ASP has several other applications in constraint-based software testing research and can be utilized to express and solve similar test case generation problems where constraints play a key role in determining the complexity of searches.

Cautious reasoning in ASP via minimal models and unsatisfiable cores

AbstractAnswer Set Programming (ASP) is a logic-based knowledge representation framework, supporting—among other reasoning modes—the central task of query answering. In the propositional case, query answering amounts to computing cautious consequences of the input program among the atoms in a given set of candidates, where a cautious consequence is an atom belonging to all stable models. Currently, the most efficient algorithms either iteratively verify the existence of a stable model of the input program extended with the complement of one candidate, where the candidate is heuristically selected, or introduce a clause enforcing the falsity of at least one candidate, so that the solver is free to choose which candidate to falsify at any time during the computation of a stable model. This paper introduces new algorithms for the computation of cautious consequences, with the aim of driving the solver to search for stable models discarding more candidates. Specifically, one of such algorithms enforces minimality on the set of true candidates, where different notions of minimality can be used, and another takes advantage of unsatisfiable cores computation. The algorithms are implemented inwasp, and experiments on benchmarks from the latest ASP competitions show that the new algorithms perform better than the state of the art.

Quantitative Methods for Similarity in Description Logics

Description logics (DLs) are a family of logic-based knowledge representation languages used to describe the knowledge of an application domain and reason about it in a formally well-defined way. However, all classical DLs have in common that they can only express exact knowledge, and correspondingly only allow exact inferences. In practice though, knowledge is rarely exact. Many definitions have exceptions or are vaguely formulated in the first place, and people might not only be interested in exact answers, but also in alternatives that are “close enough”. We are interested in tackling how to express that something is “close enough”, and how to integrate this notion into the formalism of DLs. To this end we employ the notion of similarity and dissimilarity measures, we will look at how useful measures can be defined in the context of DLs and two particular applications: Relaxed instance queries will use a similarity measure in order to not just give the exact answer to some query, but all answers that are reasonably similar. Prototypical definitions on the other hand use a measure of dissimilarity or distance between concepts in order to allow the definitions of and reasoning with concepts that capture not just those individuals that satisfy exactly the stated properties, but also those that are “close enough”.

Commonsense Interpretation of Triangle Behavior

The ability to infer intentions, emotions, and other unobservable psychological states from people's behavior is a hallmark of human social cognition, and an essential capability for future Artificial Intelligence systems. The commonsense theories of psychology and sociology necessary for such inferences have been a focus of logic-based knowledge representation research, but have been difficult to employ in robust automated reasoning architectures. In this paper we model behavior interpretation as a process of logical abduction, where the reasoning task is to identify the most probable set of assumptions that logically entail the observable behavior of others, given commonsense theories of psychology and sociology. We evaluate our approach using Triangle-COPA, a benchmark suite of 100 challenge problems based on an early social psychology experiment by Fritz Heider and Marianne Simmel. Commonsense knowledge of actions, social relationships, intentions, and emotions are encoded as defeasible axioms in first-order logic. We identify sets of assumptions that logically entail observed behaviors by backchaining with these axioms to a given depth, and order these sets by their joint probability assuming conditional independence. Our approach solves almost all (91) of the 100 questions in Triangle-COPA, and demonstrates a promising approach to robust behavior interpretation that integrates both logical and probabilistic reasoning.

Learning in Description Logics with Fuzzy Concrete Domains

Description Logics (DLs) are a family of logic-based Knowledge Representation (KR) formalisms, which are particularly suitable for representing incomplete yet precise structured knowl- edge. Several fuzzy extensions of DLs have been proposed in the KR field in order to handle im- precise knowledge which is particularly pervading in those domains where entities could be better described in natural language. Among the many approaches to fuzzification in DLs, a simple yet interesting one involves the use of fuzzy concrete domains. In this paper, we present a method for learning within the KR framework of fuzzy DLs. The method induces fuzzy DL inclusion axioms from any crisp DL knowledge base. Notably, the induced axioms may contain fuzzy concepts au- tomatically generated from numerical concrete domains during the learning process. We discuss the results obtained on a popular learning problem in comparison with state-of-the-art DL learning algorithms, and on a test bed in order to evaluate the classification performance.

A Comparison of Paraconsistent Description Logics

Description logics (DLs) are a family of logic-based knowledge representation formalisms with a number of computer science applications. DLs are especially well-known to be valuable for obtaining logical foundations of web ontology languages (e.g., W3C’s ontology language OWL). Paraconsistent (or inconsistency-tolerant) description logics (PDLs) have been studied to cope with inconsistencies which may frequently occur in an open world. In this paper, a comparison and survey of PDLs is presented. It is shown that four existing paraconsistent semantics (i.e., four-valued semantics, quasi-classical semantics, single-interpretation semantics and dual-interpretation semantics) for PDLs are essentially the same semantics. To show this, two generalized and extended new semantics are introduced, and an equivalence between them is proved.

Finding all justifications in Snomed ct

SNOMED CT is a large-scale medical ontology which is developed using a variant of the inexpressive Description Logic EL, a logic-based knowledge representation formalism and a logical underpinning of OWL 2 EL Profile. Description Logic reasoning can be used to compute subsumption relationships between SNOMED CT concepts and to pinpoint the reasons why a certain subsumption holds by finding justifications (sets of axioms responsible for this relationship). This helps the ontology developers to understand such a relationship and to debug it if needed. This article describes an extension of the method of finding one justification to one that finds all justifications for a given subsumption, introduces a SNOMED CT-specific optimization, and presents empirical evaluation results. Our extensive experiments on SNOMED CT show that (i) the proposed modularization-based approach makes it practicable to find all justifications in most cases in SNOMED CT; (ii) the first ten justifications, if any, for a subsumption can be computed in an acceptable runtime, and can be displayed in an incremental manner, i.e., the ontology developers may inspect the first justification while the reasoner continues to find more; and (iii) there is a high degree of commonality among justifications for a subsumption of interest.

Ontology-based data access: An application to intermodal logistics

In this paper, we investigate ontology-based data access (OBDA) to build information systems whose purposes are (i) gathering data from a network of intermodal terminals, and (ii) computing performance indicators of the network. This application domain is characterized by large amounts of data and relatively simple data models, making it a natural challenge for logic-based knowledge representation and reasoning techniques. Considering relational database (RDB) technology as a yardstick, we show that careful engineering of OBDA can achieve RDB-like scalability even in demanding applications. To the best of our knowledge, this is the first study evaluating the potential of OBDA in a typical business-size application.

On a Logic for Coalitional Games with Priced-Resource Agents

Alternating-time Temporal Logic (ATL) and Coalition Logic (CL) are well-established logical formalisms particularly suitable to model games between dynamic coalitions of agents (like e.g. the system and the environment). Recently, the ATL formalism has been extended in order to take into account boundedness of the resources needed for a task to be performed. The resulting logic, called Resource-BoundedATL (RB-ATL), has been presented in quite a variety of scenarios. Even if the model checking problem for extensions of ATL dealing with resource bounds is usually undecidable, a model checking procedure for RB-ATL has been proposed. In this paper, we introduce a new formalism, called PRB-ATL, based on a different notion of resource bounds and we show that its model checking problem remains in EXPTIME and has a PSPACE lower bound.Then, we tackle the problem of coalition formation. How and why agents should aggregate is not a new issue and has been deeply investigated, in past and recent years, in various frameworks, as for example in algorithmic game theory, argumentation settings, and logic-based knowledge representation. We face this problem in the setting of priced resource-bounded agents with the goal specified by an ATL formula. In particular we solve the problem of determining the minimal cost coalitions of agents acting in accordance to rules expressed by a priced game arena and satisfying a given formula. We show that such problem is computationally not harder than verifying the satisfaction of the same formula with fixed coalitions.

(Re)configuration based on model generation

Reconfiguration is an important activity for companies selling configurable products or services which have a long life time. However, identification of a set of required changes in a legacy configuration is a hard problem, since even small changes in the requirements might imply significant modifications. In this paper we show a solution based on answer set programming, which is a logic-based knowledge representation formalism well suited for a compact description of (re)configuration problems. Its applicability is demonstrated on simple abstractions of several real-world scenarios. The evaluation of our solution on a set of benchmark instances derived from commercial (re)configuration problems shows its practical applicability.

Reasoning about coalitional games

We develop, investigate, and compare two logic-based knowledge representation formalisms for reasoning about coalitional games. The main constructs of Coalitional Game Logic ( cgl) are expressions for representing the ability of coalitions, which may be combined with expressions for representing the preferences that agents have over outcomes. Modal Coalitional Game Logic ( mcgl) is a normal modal logic, in which the main construct is a modality for expressing the preferences of groups of agents. For both frameworks, we give complete axiomatisations, and show how they can be used to characterise solution concepts for coalitional games. We show that, while cgl is more expressive than mcgl, the former can only be used to reason about coalitional games with finitely many outcomes, while mcgl can be used to reason also about games with infinitely many outcomes, and is in addition more succinct. We characterise the computational complexity of satisfiability for cgl, and give a tableaux-based decision procedure.

Semantic model-driven development of web service architectures

Building service-based architectures has become a major area of interest since the advent of web services. Modelling these architectures is a central activity. Model-driven development is a recent approach to developing software systems based on the idea of making models the central artefacts for design representation, analysis and code generation. We propose an ontology-based engineering methodology for semantic model-driven composition and transformation of web service architectures. Ontology technology as a logic-based knowledge representation and reasoning framework can provide answers to the needs of sharable and reusable semantic models and descriptions needed for service engineering. Based on modelling, composition and code generation techniques for service architectures, our approach provides a methodological framework for ontology-based semantic service architecture.

Implementing logic spreadsheets in LESS

AbstractSpreadsheets are a widespread tool for a variety of tasks, particularly in business settings. Spreadsheet users employ a form of programming that, although popular, is highly error-prone and has limited expressiveness. A promising approach to overcome these shortcomings is to augment spreadsheets with logic-based knowledge representation and reasoning (KR&amp;R) functionality. In this paper, we present Logic Embedded in SpreadSheets (LESS), a system which integrates PowerLoom, a highly expressive logic-based KR&amp;R system, with Microsoft (MS) Excel. The design of LESS provides different tiers of functionality that explore trade-offs between direct access to the underlying logic engine and user-friendly support for spreadsheets users. A prototype of LESS was implemented as an MS Excel add-in.

Hybrid Logics and Ontology Languages

Description Logics (DLs) are a family of logic based knowledge representation formalisms. Although they have a range of applications, they are perhaps best known as the basis for widely used ontology languages such as OIL, DAML+OIL and OWL, the last of which is now a World Wide Web Consortium (W3C) recommendation. SHOIN, the DL underlying OWL DL (the most widely used “species” of OWL), includes familiar features from hybrid logic. In particular, in order to support extensionally defined classes, SHOIN includes nominals: classes whose extension is a singleton set. This is an important feature for a logic that is designed for use in ontology language applications, because extensionally defined classes are very common in ontologies. Binders and state variables are another feature from Hybrid Logic that would clearly be useful in an ontology language, but it is well known that adding this feature to even a relatively weak language would lead to undecidability. However, recent work has shown that this feature could play a very useful role in query answering, where the syntactic structure of queries means that the occurrence of state variables is restricted in a way that allows for decidable reasoning.