Huawei is currently undertaking an effort to build map and web search services using query understanding and semantic search techniques. We present our efforts to built a low-latency type mention detection and linking service for map search. In addition to latency challenges, we only had access to low quality and biased training data plus we had to support 13 languages. Consequently, our service is based mostly on unsupervised term- and vector-based methods. Nevertheless, we trained a Transformer-based query tagger which we integrated with the rest of the pipeline using a reward and penalisation approach. We present techniques that we designed in order to address challenges with the type dictionary, incompatibilities in scoring between the term-based and vector-based methods as well as over-segmentation issues in Thai, Chinese, and Japanese. We have evaluated our approach on the Huawei map search use case as well as on community Question Answering benchmarks.

A large number of conceptually different medical coding and classification systems are in use in medical practice, of which the most popular are ICD-9, ICD-10, and Read Codes. To achieve interoperability, a platform that enables translation between them is needed. In this paper we report on the progress of Babylon Health in developing such an interoperability platform. Based on state-of-the-art partial mapping approaches, we propose a methodology for integrating coding systems into Babylon’s medical Knowledge Graph and propose a code translation algorithm in which this Knowledge Graph acts as a mediator.

A wealth of medical knowledge has been encoded in terminologies like SNOMED CT, NCI, FMA, and more. However, these resources are usually lacking information like relations between diseases, symptoms, and risk factors preventing their use in diagnostic or other decision making applications. In this paper we present a pipeline for extracting such information from unstructured text and enriching medical knowledge bases. Our approach uses Semantic Role Labelling and is unsupervised. We show how we dealt with several deficiencies of SRL-based extraction, like copula verbs, relations expressed through nouns, and assigning scores to extracted triples. The system have so far extracted about 120K relations and in-house doctors verified about 5k relationships. We compared the output of the system with a manually constructed network of diseases, symptoms and risk factors build by doctors in the course of a year. Our results show that our pipeline extracts good quality and precise relations and speeds up the knowledge acquisition process considerably.

This paper explores how the logical difference between two ontologies can be tracked using a forgetting-based or uniform interpolation (UI)-based approach. The idea is that rather than computing all entailments of one ontology not entailed by the other ontology, which would be computationally infeasible, only the strongest entailments not entailed in the other ontology are computed. To overcome drawbacks of existing forgetting/uniform interpolation tools we introduce a new forgetting method designed for the task of computing the logical difference between different versions of large-scale ontologies. The method is sound and terminating, and can compute uniform interpolants for ALC-ontologies as large as SNOMED CT and NCIt. Our evaluation shows that the method can achieve considerably better success rates (>90%) and provides a feasible approach to computing the logical difference in large-scale ontologies, as a case study on different versions of SNOMED CT and NCIt ontologies shows.

The use of ontologies in applications like dialogue systems, question-answering or decision-support is gradually gaining attention. In such applications, keyword-based user queries are mapped to ontology entities and then the respective application logic is activated. This task is not trivial as user queries may often be vague and imprecise or simply don’t match the entities recognised by the application. This is for example the case in symptom-checking dialogue systems where users can enter text like “I am not feeling well”, “I sleep terribly”, and more, which cannot be directly matched to entities found in formal medical ontologies. In the current paper we present a framework for automatically building a small dialogue for the purposes of bridging the gap between user queries and a set of pre-defined (target) ontology concepts. We show how we can use the ontology and statistical techniques to select an initial small set of candidate concepts from the target ones and how these can then be grouped into categories using their properties in the ontology. Using these groups we can ask the user questions in order to try and reduce the set of candidates to a single concept that captures the initial user intention. The effectiveness of this approach is hindered by well-known underspecification of ontologies which we address by a concept enrichment pre-processing step based on information extraction techniques. We have instantiated our framework and performed a preliminary evaluation largely motivated by a real-world symptom-checking application obtaining encouraging results.

Query rewriting is an important technique for answering queries over data described using ontologies. In query rewriting the input, a conjunctive query (CQ) |$q$| and an ontology |$\mathcal {O}$|⁠, is transformed into a new datalog query that captures all answers of |$q$| over |$\mathcal {O}$| and any dataset |$D$|⁠. This process can be time-consuming as it is of high computational complexity. In many real-world applications, this can be particularly problematic as they involve frequent and relatively small modifications on quite large ontologies. Hence, a drawback of most of modern query rewriting systems is that every time the initial ontology is modified, e.g. when new axioms are added or existing ones removed, they compute a new rewriting from scratch. In this paper, we study the problem of computing a rewriting for a CQ over an ontology that has been modified. We do this by reusing the information obtained by the extraction of some previous rewriting with the goal of performing the least possible computations. We study the problem theoretically, present detailed algorithms for both ontology revision and ontology contraction and finally, present an extensive experimental evaluation using the well-known query rewriting systems Requiem and Rapid.

Computing a (Union of Conjunctive Queries - UCQ) rewriting R for an input query and ontology and evaluating it over the given dataset is a prominent approach to query answering over ontologies. However, R can be large and complex in structure hence additional techniques, like query subsumption and data constraints, need to be employed in order to minimise Rew and lead to an efficient evaluation. Although sound in theory, how to efficiently and effectively implement many of these techniques in practice could be challenging. For example, many systems do not implement query subsumption. In the current paper we present several practical techniques for UCQ rewriting minimisation. First, we present an optimised algorithm for eliminating redundant (w.r.t. subsumption) queries as well as a novel framework for rewriting minimisation using data constraints. Second, we show how these techniques can also be used to speed up the computation of R in the first place. Third, we integrated all our techniques in our query rewriting system IQAROS and conducted an extensive experimental evaluation using many artificial as well as challenging real-world ontologies obtaining encouraging results as, in the vast majority of cases, our system is more efficient compared to the two most popular state-of-the-art systems.

Fuzzy extensions to description logics (DLs) have gained considerable attention the last decade. So far most works on fuzzy DLs have focused on either very expressive languages, like fuzzy OWL and OWL 2, or on highly inexpressive ones, like fuzzy OWL 2 QL and fuzzy OWL 2 EL. To the best of our knowledge, a fuzzy extension to the language OWL 2 RL has not been thoroughly studied so far. This language is very relevant since it combines both adequate expressive power as well as efficient reasoning algorithms which can be realized using rule-based (Datalog) technologies. In contrast to previous fuzzy extensions, a fuzzy extension of OWL 2 RL is not a straightforward task for the following reason. The main motivation of OWL 2 RL is that its axioms can be equivalently represented as Datalog rules. Hence, to achieve our goal we need to investigate which OWL 2 RL axioms when interpreted under the fuzzy setting can be transformed to equivalent fuzzy Datalog rules. We show that this is not, in general, possible for all axioms but we show that this ‘issue’ can to a large extent be alleviated. Moreover, we have performed an experimental evaluation with many well-known ontologies which showed that such axioms are not used so often in practice.

Query answering over OWL 2 DL ontologies is an important reasoning task for many modern applications. Unfortunately, due to its high computational complexity, OWL 2 DL systems are still not able to cope with datasets containing billions of data. Consequently, application developers often employ provably scalable systems which only support a fragment of OWL 2 DL and which are, hence, most likely incomplete for the given input. However, this notion of completeness is too coarse since it implies that there exists some query and some dataset for which these systems would miss answers. Nevertheless, there might still be a large number of user queries for which they can compute all the right answers even over OWL 2 DL ontologies. In the current paper, we investigate whether, given a query 𝒬 with only distinguished variables over an OWL 2 DL ontology 𝒯 and a system ans, it is possible to identify in an efficient way if ans is complete for 𝒬, 𝒯 and every dataset. We give sufficient conditions for (in)completeness and present a hybrid query answering algorithm which uses ans when it is complete, otherwise it falls back to a fully-fledged OWL 2 DL reasoner. However, even in the latter case, our algorithm still exploits ans as much as possible in order to reduce the search space of the OWL 2 DL reasoner. Finally, we have implemented our approach using a concrete system ans and OWL 2 DL reasoner obtaining encouraging results.

Query rewriting is a prominent reasoning technique in ontology-based data access applications. A wide variety of query rewriting algorithms have been proposed in recent years and implemented in highly optimised reasoning systems. Query rewriting systems are complex software programs; even if based on provably correct algorithms, sophisticated optimisations make the systems more complex and errors become more likely to happen. In this paper, we present an algorithm that, given an ontology as input, synthetically generates ``relevant'' test queries. Intuitively, each of these queries can be used to verify whether the system correctly performs a certain set of ``inferences'', each of which can be traced back to axioms in the input ontology. Furthermore, we present techniques that allow us to determine whether a system is unsound and/or incomplete for a given test query and ontology. Our evaluation shows that most publicly available query rewriting systems are unsound and/or incomplete, even on commonly used benchmark ontologies; more importantly, our techniques revealed the precise causes of their correctness issues and the systems were then corrected based on our feedback. Finally, since our evaluation is based on a larger set of test queries than existing benchmarks, which are based on hand-crafted queries, it also provides a better understanding of the scalability behaviour of each system.

To achieve scalability of query answering, the developers of Semantic Web applications are often forced to use incomplete OWL 2 reasoners, which fail to derive all answers for at least one query, ontology, and data set. The lack of completeness guarantees, however, may be unacceptable for applications in areas such as health care and defence, where missing answers can adversely affect the application's functionality. Furthermore, even if an application can tolerate some level of incompleteness, it is often advantageous to estimate how many and what kind of answers are being lost. In this paper, we present a novel logic-based framework that allows one to check whether a reasoner is complete for a given query Q and ontology T---that is, whether the reasoner is guaranteed to compute all answers to Q w.r.t. T and an arbitrary data set A. Since ontologies and typical queries are often fixed at application design time, our approach allows application developers to check whether a reasoner known to be incomplete in general is actually complete for the kinds of input relevant for the application. We also present a technique that, given a query Q, an ontology T, and reasoners R_1 and R_2 that satisfy certain assumptions, can be used to determine whether, for each data set A, reasoner R_1 computes more answers to Q w.r.t. T and A than reasoner R_2. This allows application developers to select the reasoner that provides the highest degree of completeness for Q and T that is compatible with the application's scalability requirements. Our results thus provide a theoretical and practical foundation for the design of future ontology-based information systems that maximise scalability while minimising or even eliminating incompleteness of query answers.

Largely motivated by Semantic Web applications, many highly scalable, but incomplete, query answering systems have been recently developed. Evaluating the scalability-completeness trade-off exhibited by such systems is an important requirement for many applications. In this paper, we address the problem of formally comparing complete and incomplete systems given an ontology schema (or TBox) T. We formulate precise conditions on TBoxes T expressed in the EL, QL or RL profile of OWL 2 under which an incomplete system is indistinguishable from a complete one w.r.t. T, regardless of the input query and data. Our results also allow us to quantify the “degree of incompleteness” of a given system w.r.t. T as well as to automatically identify concrete queries and data patterns for which the incomplete system will miss answers.

Conjunctive query answering is a key reasoning service for many ontology-based applications. In order to improve scalability, many Semantic Web query answering systems give up completeness (i.e., they do not guarantee to return all query answers). It may be useful or even critical to the designers and users of such systems to understand how much and what kind of information is (potentially) being lost. We present a method for generating test data that can be used to provide at least partial answers to these questions, a purpose for which existing benchmarks are not well suited. In addition to developing a general framework that formalises the problem, we describe practical data generation algorithms for some popular ontology languages, and present some very encouraging results from our preliminary evaluation.

Description logics (DLs) are modern knowledge representation formalisms which are used today in many applications for reasoning with structured knowledge. Moreover, they are used in the semantic web (an extension of the current web) through the ontology language OWL. On the other hand fuzzy description logics (fuzzy-DLs) have been proposed as expressive logical formalisms capable of capturing and reasoning with vague and imprecise knowledge in the semantic web. In the current paper we investigate on the problem of reasoning with qualified cardinality restrictions (QCRs) in fuzzy DLs, extending previous results on simple number restrictions, thus we present a tableaux algorithm for the the fuzzy-DL fKD-ALCIQ.

Fuzzy ontologies are envisioned to be useful in the Semantic Web. Existing fuzzy ontology reasoners are not scalable enough to handle the scale of data that the Web provides. In this paper, we propose a framework of fuzzy query languages for fuzzy ontologies, and present query answering algorithms for these query languages over fuzzy DL-Lite ontologies. Moreover, this paper reports on implementation of our approach in the fuzzy DL-Lite query engine in the ONTOSEARCH2 system and preliminary, but encouraging, benchmarking results. To the best of our knowledge, this is the first ever scalable query engine for fuzzy ontologies.

The Semantic Web can be viewed as largely about "Knowledge meets the Web". Thus its vision includes ontologies and rules. A key requirement for the architecture of the Semantic Web is to be able to layer "rules on top of ontologies" and "ontologies on top of rules". This has as a counterpart the definition of a mapping between Description Logics and Logic Programming, which is known as Description Logic Programs. In this paper we extend the Description Logic Programs with fuzzy sets and fuzzy logic in order to be able to represent the imprecision and vagueness of real-life applications. We provide the common semantics of the mapping, and the conditions that must be met for this semantic equivalence, based on the model-theoretic semantics.

It is widely recognized today that the management of imprecision and vagueness will yield more intelligent and realistic knowledge-based applications. Description Logics (DLs) are a family of knowledge representation languages that have gained considerable attention the last decade, mainly due to their decidability and the existence of empirically high performance of reasoning algorithms. In this paper, we extend the well known fuzzy ALC DL to the fuzzy SHIN DL, which extends the fuzzy ALC DL with transitive role axioms (S), inverse roles (I), role hierarchies (H) and number restrictions (N). We illustrate why transitive role axioms are difficult to handle in the presence of fuzzy interpretations and how to handle them properly. Then we extend these results by adding role hierarchies and finally number restrictions. The main contributions of the paper are the decidability proof of the fuzzy DL languages fuzzy-SI and fuzzy-SHIN, as well as decision procedures for the knowledge base satisfiability problem of the fuzzy-SI and fuzzy-SHIN.