4,515 research outputs found
Using Description Logics for RDF Constraint Checking and Closed-World Recognition
RDF and Description Logics work in an open-world setting where absence of
information is not information about absence. Nevertheless, Description Logic
axioms can be interpreted in a closed-world setting and in this setting they
can be used for both constraint checking and closed-world recognition against
information sources. When the information sources are expressed in well-behaved
RDF or RDFS (i.e., RDF graphs interpreted in the RDF or RDFS semantics) this
constraint checking and closed-world recognition is simple to describe. Further
this constraint checking can be implemented as SPARQL querying and thus
effectively performed.Comment: Extended version of a paper of the same name that will appear in
AAAI-201
Compliance checking in reified IO logic via SHACL
Reified Input/Output (I/O) logic[21] has been recently proposed to model real-world norms in terms of the logic in [11]. This is massively grounded on the notion of reification, and it has specifically designed to model meaning of natural language sentences, such as the ones occurring in existing legislation. This paper presents a methodology to carry out compliance checking on reified I/O logic formulae. These are translated in SHACL (Shapes Constraint Language) shapes, a recent W3C recommendation to validate and reason with RDF triplestores. Compliance checking is then enforced by validating RDF graphs describing states of affairs with respect to these SHACL shapes
Answering SPARQL queries modulo RDF Schema with paths
SPARQL is the standard query language for RDF graphs. In its strict
instantiation, it only offers querying according to the RDF semantics and would
thus ignore the semantics of data expressed with respect to (RDF) schemas or
(OWL) ontologies. Several extensions to SPARQL have been proposed to query RDF
data modulo RDFS, i.e., interpreting the query with RDFS semantics and/or
considering external ontologies. We introduce a general framework which allows
for expressing query answering modulo a particular semantics in an homogeneous
way. In this paper, we discuss extensions of SPARQL that use regular
expressions to navigate RDF graphs and may be used to answer queries
considering RDFS semantics. We also consider their embedding as extensions of
SPARQL. These SPARQL extensions are interpreted within the proposed framework
and their drawbacks are presented. In particular, we show that the PSPARQL
query language, a strict extension of SPARQL offering transitive closure,
allows for answering SPARQL queries modulo RDFS graphs with the same complexity
as SPARQL through a simple transformation of the queries. We also consider
languages which, in addition to paths, provide constraints. In particular, we
present and compare nSPARQL and our proposal CPSPARQL. We show that CPSPARQL is
expressive enough to answer full SPARQL queries modulo RDFS. Finally, we
compare the expressiveness and complexity of both nSPARQL and the corresponding
fragment of CPSPARQL, that we call cpSPARQL. We show that both languages have
the same complexity through cpSPARQL, being a proper extension of SPARQL graph
patterns, is more expressive than nSPARQL.Comment: RR-8394; alkhateeb2003
Shape Expressions Schemas
We present Shape Expressions (ShEx), an expressive schema language for RDF
designed to provide a high-level, user friendly syntax with intuitive
semantics. ShEx allows to describe the vocabulary and the structure of an RDF
graph, and to constrain the allowed values for the properties of a node. It
includes an algebraic grouping operator, a choice operator, cardinalitiy
constraints for the number of allowed occurrences of a property, and negation.
We define the semantics of the language and illustrate it with examples. We
then present a validation algorithm that, given a node in an RDF graph and a
constraint defined by the ShEx schema, allows to check whether the node
satisfies that constraint. The algorithm outputs a proof that contains
trivially verifiable associations of nodes and the constraints that they
satisfy. The structure can be used for complex post-processing tasks, such as
transforming the RDF graph to other graph or tree structures, verifying more
complex constraints, or debugging (w.r.t. the schema). We also show the
inherent difficulty of error identification of ShEx
Evaluating Knowledge Representation and Reasoning Capabilites of Ontology Specification Languages
The interchange of ontologies across the World Wide Web (WWW) and the cooperation among heterogeneous agents placed on it is the main reason for the development of a new set of ontology specification languages, based on new web standards such as XML or RDF. These languages (SHOE, XOL, RDF, OIL, etc) aim to represent the knowledge contained in an ontology in a simple and human-readable way, as well as allow for the interchange of ontologies across the web. In this paper, we establish a common framework to compare the expressiveness of "traditional" ontology languages (Ontolingua, OKBC, OCML, FLogic, LOOM) and "web-based" ontology languages. As a result of this study, we conclude that different needs in KR and reasoning may exist in the building of an ontology-based application, and these needs must be evaluated in order to choose the most suitable ontology language(s)
Verification and Validation of Semantic Annotations
In this paper, we propose a framework to perform verification and validation
of semantically annotated data. The annotations, extracted from websites, are
verified against the schema.org vocabulary and Domain Specifications to ensure
the syntactic correctness and completeness of the annotations. The Domain
Specifications allow checking the compliance of annotations against
corresponding domain-specific constraints. The validation mechanism will detect
errors and inconsistencies between the content of the analyzed schema.org
annotations and the content of the web pages where the annotations were found.Comment: Accepted for the A.P. Ershov Informatics Conference 2019(the PSI
Conference Series, 12th edition) proceedin
Semantics and Validation of Shapes Schemas for RDF
We present a formal semantics and proof of soundness for shapes schemas, an
expressive schema language for RDF graphs that is the foundation of Shape
Expressions Language 2.0. It can be used to describe the vocabulary and the
structure of an RDF graph, and to constrain the admissible properties and
values for nodes in that graph. The language defines a typing mechanism called
shapes against which nodes of the graph can be checked. It includes an
algebraic grouping operator, a choice operator and cardinality constraints for
the number of allowed occurrences of a property. Shapes can be combined using
Boolean operators, and can use possibly recursive references to other shapes.
We describe the syntax of the language and define its semantics. The
semantics is proven to be well-defined for schemas that satisfy a reasonable
syntactic restriction, namely stratified use of negation and recursion. We
present two algorithms for the validation of an RDF graph against a shapes
schema. The first algorithm is a direct implementation of the semantics,
whereas the second is a non-trivial improvement. We also briefly give
implementation guidelines
Correcting Knowledge Base Assertions
The usefulness and usability of knowledge bases (KBs) is often limited by quality issues. One common issue is the presence of erroneous assertions, often caused by lexical or semantic confusion. We study the problem of correcting such assertions, and present a general correction framework which combines lexical matching, semantic embedding, soft constraint mining and semantic consistency checking. The framework is evaluated using DBpedia and an enterprise medical KB
- …