Comparing Index Structures for Completeness Reasoning

Comparing Index Structures
for Completeness Reasoning
Fariz Darari*, Werner Nutt†, Simon Razniewski‡
*Universitas Indonesia, Indonesia
†Free University of Bozen-Bolzano, Italy
‡Max Planck Institute for Informatics, Germany
IWBIS 2018 - Jakarta, Indonesia

Imagine you are a Spielberg movie fan

who happens to be a knowledge graph fan too

Now you want to query to the knowledge graph:
Give movies written by Spielberg!
Movies written by Spielberg?

The knowledge graph gives some answers..
Answers
Poltergeist
ET
.....

Answers
Poltergeist
ET
.....
But are these answers complete?

Answers
Poltergeist
ET
.....
But are these answers complete? Maybe.
Maybe yes,
maybe no..

who happens to be a knowledge graph fan too*
Darari, et al. Completeness Statements about RDF Data Sources and Their Use for Query Answering. ISWC 2013.
*But now the knowledge graph has been augmented with completeness statements, as in:
This knowledge graph is complete
for all movies written by Spielberg

Now you want to query to the knowledge graph:
Give movies written by Spielberg!

Answers
Poltergeist
ET
.....
But are these answers complete?

Answers
Poltergeist
ET
.....
But are these answers complete? Yes!

Completeness reasoning:
Checking if completeness statements guarantee query completeness
Query: (?x, type, Movie), (?x, writtenBy, Spielberg)
Completeness statement:
(?x, type, Movie), (?x, writtenBy, Spielberg)

Completeness reasoning:
Checking if completeness statements guarantee query completeness
Completeness statement:
Can the statement(s) cover all query components?
In general, multiple completeness statements may be required
to cover all components of the query!

Completeness reasoning scalability challenge:
What if there were a million completeness statements?*
*We'd need this many because a large KG (= knowledge graph) naturally
would require many completeness statements!
Query
X 1 million!

X 1 million!
Query
Unoptimized completeness reasoning
takes minutes!

X 1 million!
Query
Unoptimized completeness reasoning
takes minutes!
Can we do any better?

We propose techniques
for scalable completeness reasoning
Our contributions:
1. Principle for filtering out irrelevant completeness statements
2. Indexing methods for completeness statements
3. Experimental evaluations of
naive completeness reasoning vs. indexed completeness reasoning

Constant-relevance principle
A statement contributes to query completeness only if
its constants are among the query’s
Completeness statements:
(?x, type, Movie), (?x, writtenBy, Bob)
(?x, type, Song, (?x, writtenBy, Mary)
(Spielberg, child, ?y)

Constants:
type, Movie, writtenBy, Spielberg
type, Movie, writtenBy, Bob
type, Song, writtenBy, Mary
Spielberg, child

Constants: type, Movie, writtenBy, Spielberg
Constants:
Spielberg, child

Constant-relevance principle: subset querying
Constants: type, Movie, writtenBy, Spielberg
Constants:
Spielberg, child
Reduce the problem into:
Subset querying
Retrieve completeness statements
whose constants are subsets of
the query's constants

Index structure for subset querying:
Standard hashing, inverted index, trie
Subset querying
Hash indexes map keys to values: Set-equality queries
How do we perform subset querying using hash indexes?

Subset querying
Hash indexes map keys to values: Set-equality queries
How do we perform subset querying using hash indexes?
By enumerating all possible non-empty subsets of query constants!

Subset querying
const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b

Subset querying
const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b
M(a, b) = C1
M(a, b, c) = C2, C3
M(d) = C4

Subset querying
const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b
M(a, b) = C1
M(a, b, c) = C2, C3
M(d) = C4
Relevant completeness statements:
M(a) U M(b) U M(a, b) = C1

const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b
Subset querying

const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b
Subset querying
Bag(Q) = Inv(a) U Inv(b)
= C1, C2, C3, C1, C2, C3
Constant-relevant statements:
Those statements appearing as many times in Bag(Q)
as the statements' constants

const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b
Subset querying
Traverse the above trie using
query constant sequence (a, b)

const(C1) = a, b
const(C2) = a, b, c
const(C3) = a, b, c
const(C4) = d
const(Q) = a, b
Subset querying
Traverse the above trie using
query constant sequence (a, b)
visited node = constant-relevant

Experimental evaluation:
Setup
Synthetic dataset with realistic parameters
from DBpedia, a large real-world knowledge graph
Parameters:
- Number of completeness statements, default value: 1 million
- Max length of completeness statements, default value: 6
- Query length, two default values, short = 3 and long = 6

Results – Varying number of statements
Short queries Long queries

Results – Varying max length of statements
Short queries Long queries

Results – Varying query length

Results – Unoptimized vs Indexed Reasoning

Results – Unoptimized vs Indexed Reasoning
Conclusion: We fast forward completeness reasoning.

Comparing Index Structures for Completeness Reasoning

Comparing Index Structures for Completeness Reasoning

Related slideshows

More Related Content

Comparing Index Structures for Completeness Reasoning

Editor's Notes