Observing LOD using Equivalent Set Graphs: it is mostly flat and sparsely linked

TL;DR

This paper empirically analyzes the structure of Linked Open Data, revealing its flat and sparsely linked nature, and introduces a framework and tools for further analysis of such data.

Contribution

It provides a novel conceptual framework with metrics and an open source tool for analyzing the semantic structure of Linked Open Data.

Findings

LOD is mostly flat and sparsely linked

Hierarchies of concepts are loosely structured

The framework and tools facilitate LOD analysis

Abstract

This paper presents an empirical study aiming at understanding the modeling style and the overall semantic structure of Linked Open Data. We observe how classes, properties and individuals are used in practice. We also investigate how hierarchies of concepts are structured, and how much they are linked. In addition to discussing the results, this paper contributes (i) a conceptual framework, including a set of metrics, which generalises over the observable constructs; (ii) an open source implementation that facilitates its application to other Linked Data knowledge graphs.

Tables

Table 1. Table 1 : Statistics computed on the equivalent set graph for properties and classes, from LOD-a-lot. They include the metrics defined in Section  3.4 . IES(n) indicates the Number of Equivalent Sets having indirect size n or greater. The term entity is here used to refer to classes and properties.

Metrics		Property	Class
# of Observed Entities	$OE$	1,308,946	4,857,653
# of Observed Entities without BNs	$O{E}_{bn}$	1,301,756	3,719,371
# of Blank Nodes (BNs)	$BN$	7,190	1,013,224
# of Equivalence Sets (ESs)	$ES$	1,305,364	4,038,722
# of Equivalence Sets (ESs) without BNs	$E{S}_{bn}$	1,298,174	3,092,523
Ratio between ES and OE	R	.997	.831
Ratio between ES and OE without BNs	$R_{bn}$	.997	.831
# of Edges	E	147,606	5,090,482
Maximum Height	$H_{max}$	14	77
# Isolated ESs	$IN$	1,157,825	288,614
# of Top Level ESs	$TL$	1,181,583	1,281,758
# of Top Level ESs without BNs	$T{L}_{bn}$	1,174,717	341,792
# of OE in Top Level ESs	$OE$-$TL$	1,185,591	1,334,631
# of OE in Top Level ESs without BNs	$OE$-$T{L}_{bn}$	1,178,725	348,599
Ratio between TL and OE-TL	$RTL$	.996	.960
Ratio between TL and OE-TL without BNs	$RT{L}_{bn}$	.996	.980
# of Weakly Connected Components	$WCC$	1,174,152	449,332
# of Strongly Connected Components	$SCC$	1,305,364	4,038,011
# of OE with Empty Extension	$O{E}_0$	140,014	4,024,374
# of OE with Empty Extension without BNs	$O{E}_{0bn}$	132,824	2,912,700
# of ES with Empty Extension	$E{S}_0$	131,854	3,060,467
# of ES with Empty Extension without BNs	$E{S}_{0bn}$	124,717	2,251,626
# of ES with extensional size greater than 1	$IES\left(1\right)$	1,173,510	978,255
# of ES with extensional size greater than 10	$IES\left(10\right)$	558,864	478,746
# of ES with extensional size greater than 100	$IES\left(100\right)$	246,719	138,803
# of ES with extensional size greater than 1K	$IES\left(1K\right)$	79,473	30,623
# of ES with extensional size greater than 1M	$IES\left(1M\right)$	1,762	3,869
# of ES with extensional size greater than 1B	$IES\left(1B\right)$	34	1,833
# of OE-TL with Empty Extension	$OE$-$T{L}_0$	26,640	1,043,099
# of OE-TL with Empty Extension w/o BNs	$OE$-$T{L}_{0bn}$	19,774	83,674
# of TL with Empty Extension	$T{L}_0$	18,884	869,443
# of TL with Empty Extension w/o BNs	$T{L}_{0bn}$	12,071	66,805

Equations

$$\mathcal{V}\begin{array}{c}{p}_{eq},p_{sub}\\ p_e,p_s\end{array}:=\{v=\{e_1,\dots ,e_n\}|(\forall e_i,e_j\in v)(e_i\begin{array}{c}{p}_{eq}+\\ ⟺\end{array}{e}_j\in G)\}$$

$$\begin{gathered} \mathcal{E}\begin{array}{c}{p}_{eq},p_{sub}\\ p_e,p_s\end{array}:=\{(v=\{v_1,\dots ,v_n\},z=\{z_1,\dots ,z_n\})| \\ (\exists v_i\in v)(\exists z_j\in z)(\exists p\in \overline{\mathcal{C}\begin{array}{c}{p}_e,p_s\\ p_e,p_s\end{array}}(p_{sub}))(⟨v_i,p,z_j⟩\in G)\} \end{gathered}$$

$$\overline{{\mathcal{H}}^{+}\begin{array}{c}{p}_{eq},p_{sub}\\ p_e,p_s\end{array}}(e):=\{e^{\prime }|e^{\prime }\begin{array}{c}{p}_{sub}+\\ ⟹\end{array}e\in G\}$$

$$\overline{\mathcal{C}\begin{array}{c}{p}_{eq},p_{sub}\\ p_e,p_s\end{array}}(e):=\{e^{\prime }|(\exists v\in \mathcal{V}\begin{array}{c}{p}_{eq},p_{sub}\\ p_e,p_s\end{array})(e\in v\wedge e^{\prime }\in v)\}\cup \overline{{\mathcal{H}}^{+}\begin{array}{c}{p}_{eq},p_{sub}\\ p_e,p_s\end{array}}(e)$$

Full text

(i) a conceptual framework, including a set of metrics, which generalises over the observable constructs;

(ii) an open source implementation that facilitates its application to other Linked Data knowledge graphs.

1 Analysing the modeling structure and style of LOD

The interlinked collection of Linked Open Data (LOD) datasets forms the largest publicly accessible Knowledge Graph (KG) that is available on the Web today.111This paper uses the following RDF prefix declarations for brevity, and uses the empty prefix (:) to denote an arbitrary example namespace.

•

dbo: http://dbpedia.org/ontology/

•

dul: http://www.ontologydesignpatterns.org/ont/dul/DUL.owl#

•

foaf: http://xmlns.com/foaf/0.1/

•

org: http://www.w3.org/ns/org#

•

rdfs: http://www.w3.org/2000/01/rdf-schema#

•

owl: http://www.w3.org/2002/07/owl#

LOD distinguishes itself from most other forms of open data in that it has a formal semantics. Various studies have analysed different aspects of the formal semantics of LOD. However, existing analyses have often been based on relatively small samples of the ever evolving LOD KG. Moreover, it is not always clear how representative the chosen samples are. This is especially the case when observations are based on one dataset (e.g., DBpedia), or on a small number of datasets that are drawn from the much larger LOD Cloud.

This paper presents observations that have been conducted across (a very large subset of) the LOD KG. As such, this paper is not about the design of individual ontologies, rather, it is about observing the design of the globally shared Linked Open Data ontology. Specifically, this paper focuses on the globally shared hierarchies of classes and properties, together with their usage in instance data. This paper provides new insights about

(i) the number of concepts defined in the LOD KG,

(ii) the shape of ontological hierarchies,

(iii) the extent in which recommended practices for ontology alignment are followed, and

(iv) whether classes and properties are instantiated in a homogeneous way.

In order to conduct large-scale semantic analyses, it is necessary to calculate the deductive closure of very large hierarchical structures. Unfortunately, contemporary reasoners cannot be applied at this scale, unless they rely on expensive hardware such as a multi-node in-memory cluster. In order to handle this type of large-scale semantic analysis on commodity hardware such as regular laptops, we introduce the formal notion of an Equivalence Set Graph. With this notion we are able to implement efficient algorithms to build the large hierarchical structures that we need for our study.

We use the formalization and implementation presented in this paper to compute two (very large) Equivalence Set Graphs: one for classes and one for properties. By querying them, we are able to quantify various aspects of formal semantics at the scale of the LOD KG. Our observations show that there is a lack of explicit links (alignment) between ontological entities and that there is a significant number of concepts with empty extension. Furthermore, property hierarchies are observed to be mainly flat, while class hierarchies have varying depth degree, although most of them are flat too.

This paper makes the following contributions:

A new formal concept (Equivalence Set Graph) that allows us to specify compressed views of a LOD KG (presented in Section 3.2). 2. 2.

An implementation of efficient algorithms that allow Equivalence Set Graphs to be calculated on commodity hardware (cf. Section 4). 3. 3.

A detailed analysis of how classes and properties are used at the level of the whole LOD KG, using the formalization and implementation of Equivalence Set Graphs.

The remaining of this paper is organized as follows: Section 2 summarizes related work. The approach is presented in Section 3. Section 4 describes the algorithm for computing an Equivalence Set Graph form a RDF dataset. Section 3.4 defines a set of metrics that are measured in Section 5. Section 6 discusses the observed values and concludes.

2 Related Work

Although large-scale analyses of LOD have been performed since the early years of the Semantic Web, we could not find previous work directly comparable with ours. The closest we found are not recent and performed on a much smaller scale. In 2004, Gil and García [8] showed that the Semantic Web (at that time consisting of 1.3 million triples distributed over 282 datasets) behaves as a Complex System: the average path length between nodes is short (small world property), there is a high probability that two neighbors of a node are also neighbors of one another (high clustering factor), and nodes follow a power-law degree distribution. In 2008, similar results were reported by [14] in an individual analysis of 250 schemas. These two studies focus on topological graph aspects exclusively, and do not take semantics into account.

In 2005, Ding et al. [6] analysed the use of the Friend-of-a-Friend (FOAF) vocabulary on the Semantic Web. They harvested 1.5 million RDF datasets, and computed a social network based on those data datasets. They observed that the number of instances per dataset follows the Zipf distribution.

In 2006, Ding et al. [4] analysed 1.7 million datasets, containing 300 million triples. They reported various statistics over this data collection, such as the number of datasets per namespace, the number of triples per dataset, and the number of class- and property-denoting terms. The semantic observation in this study is limited since no deduction was applied.

In 2006, a survey by Wang et al. [16] aimed at assessing the use of OWL and RDF schema vocabularies in 1,300 ontologies harvested from the Web. This study reported statistics such as the number of classes, properties, and instances of these ontologies. Our study provides both an updated view on these statistics, and a much larger scale of the observation (we analysed ontological entities defined in $\sim$650k datasets crawled by LOD-a-lot [7]).

Several studies [2, 5, 9] analysed common issues with the use of owl:sameAs in practice. Mallea et al. [11] showed that blank nodes, although discouraged by guidelines, are prevalent on the Semantic Web. Recent studies [13] experimented on analysing the coherence of large LOD datasets, such as DBpedia, by leveraging foundational ontologies. Observations on the presence of foundational distinctions in LOD has been studied in [1].

These studies have a similar goal as ours: to answer the question how knowledge representation is used in practice in the Semantic Web, although the focus may partially overlap. We generalise over all equivalence (or identity) constructs instead of focusing on one specific, we observe the overall design of LOD ontologies, analysing a very large subject of it, we take semantics into account by analysing the asserted as well as the inferred data.

3 Approach

3.1 Input source

Ideally, our input is the whole LOD Cloud, which is (a common metonymy for identifying) a very large and distributed Knowledge Graph. The two largest available crawls of LOD available today are WebDataCommons and LOD-a-lot.

WebDataCommons222See http://webdatacommons.org [12] consists of $\sim$31B triples that have been extracted from the CommonCrawl datasets (November 2018 version). Since its focus is mostly on RDFa, microdata, and microformats, WebDataCommons contains a very large number of relatively small graph components that use the Schema.org333See https://schema.org vocabulary.

LOD-a-lot444See http://lod-a-lot.lod.labs.vu.nl [7] contains $\sim$28B unique triples that are the result of merging the graphs that have been crawled by LOD Laundromat [3] into one single graph. The LOD Laundromat crawl is based on data dumps that are published as part of the LOD Cloud, hence it contains relatively large graphs that are highly interlinked. The LOD-a-lot datadump is more likely to contain RDFS and OWL annotations than WebDataCommons. Since this study focuses on the semantics of Linked Open Data, it uses the LOD-a-lot datadump.

LOD-a-lot only contains explicit assertions, i.e., triples that have been literally published by some data owner. This means that the implicit assertions, i.e., triples that can be derived from explicit assertions and/or other implicit assertions, are not part of it and must be calculated by a reasoner. Unfortunately, contemporary reasoners are unable to compute the semantic closure over 28B triples. Advanced alternatives for large-scale reasoning, such as the use of clustering computing techniques (e.g., [15]) require expensive resources in terms of CPU/time and memory/space. Since we want to make running large-scale semantic analysis a frequent activity in Linked Data Science, we present a new way to perform such large-scale analyses against very low hardware cost.

This section outlines our approach for performing large-scale semantic analyses of the LOD KG. We start out by introducing the new notion of Equivalence Set Graph (ESG) (Section 3.2). Once Equivalence Set Graphs have been informally introduced, the corresponding formal definitions are given in Section 3.3. Finally, the metrics that will be measured using the ESGs are defined in Section 3.4.

3.2 Introducing Equivalence Set Graphs

An Equivalence Set Graph (ESG) is a tuple $\langle\mathcal{V},\mathcal{E},p_{eq},p_{sub},p_{e},p_{s}\rangle$. The nodes $\mathcal{V}$ of an ESG are equivalence sets of terms from the universe of discourse. The directed edges $\mathcal{E}$ of an ESG are specialization relations between those equivalence sets. $p_{eq}$ is an equivalence relation that determines which equivalence sets are formed from the terms in the universe of discourse. $p_{sub}$ is a partial order relation that determines the specialization relation between the equivalence sets. In order to handle equivalences and specializations of $p_{eq}$ and $p_{sub}$ (see below for details and examples), we introduce $p_{e}$, an equivalence relation over properties (e.g., owl:equivalentProperty) that allows to retrieve all the properties that are equivalent to $p_{eq}$ and $p_{sub}$, and $p_{s}$ which is a specialization relation over properties (e.g., rdfs:subPropertyOf) that allows to retrieve all the properties that specialize $p_{eq}$ and $p_{sub}$.

The inclusion of the parameters $p_{eq}$, $p_{sub}$, $p_{e}$, and $p_{s}$ makes the Equivalence Set Graph a very generic concept. By changing the equivalence relation ($p_{eq}$), ESG can be applied to classes (owl:equivalentClass), properties (owl:equivalentProperty), or instances (owl:sameAs). By changing the specialization relation ($p_{sub}$), ESG can be applied to class hierarchies (rdfs:subClassOf), property hierarchies (rdfs:subPropertyOf), or concept hierarchies (skos:broader).

An Equivalence Set Graph is created starting from a given RDF Knowledge Graph. The triples in the RDF KG are referred to as its explicit statements. The implicit statements are those that can be inferred from the explicit statements. An ESG must be built taking into account both the explicit and the implicit statements. For example, if $p_{eq}$ is owl:equivalentClass, then the following Triple Patterns (TP) retrieve the terms ?y that are explicitly equivalent to a given ground term :x:

{sparql} { :x owl:equivalentClass ?y } union { ?y owl:equivalentClass :x }

In order to identify the terms that are implicitly equivalent to :x, we also have to take into account the following:

The closure of the equivalence predicate (reflexive, symmetric, transitive). 2. 2.

Equivalences (w.r.t. $p_{e}$) and/or specializations (w.r.t. $p_{s}$) of the equivalence predicate ($p_{eq}$). E.g., the equivalence between :x and :y is asserted with the :sameClass predicate, which is equivalent to owl:equivalentClass):

{turtle} :sameClass owl:equivalentProperty owl:equivalentClass. :x :sameClass :y. 3. 3.

Equivalences (w.r.t. $p_{e}$) and/or specializations (w.r.t. $p_{s}$) of predicates (i.e. $p_{e}$ and $p_{s}$) for asserting equivalence or specialization relations among properties . E.g., the equivalence between :x and :y is asserted with the :sameClass predicate, which is a specialization of owl:equivalentClass according to :sameProperty, which it itself a specialization of owl:equivalentProperty:

:sameProperty rdfs:subPropertyOf owl:equivalentProperty. :sameClass :sameProperty owl:equivalentClass. :x :sameClass :y.

The same distinction between explicit and implicit statements can be made with respect to the specialization relation ($p_{sub}$). E.g., for an Equivalence Set Graph that uses rdfs:subClassOf as its specialization relation, the following TP retrieves the terms ?y that explicitly specialize a given ground term :x:

?y rdfs:subClassOf :x.

In order to identify the entities that are implicit specializations of :x, we must also take the following into account:

The closure of the specialization predicate (reflexive, anti-symmetric, transitive). 2. 2.

Equivalences (w.r.t. $p_{e}$) and/or specializations (w.r.t. $p_{s}$) of the specialization predicate ($p_{sub}$). E.g, :y is a specialization of :x according to the :subClass property, which is itself a specialization of the rdfs:subClassOf predicate:

:subClass rdfs:subPropertyOf rdfs:subClassOf. :y :subClass :x. 3. 3.

Equivalences (w.r.t. $p_{e}$) and/or specializations (w.r.t. $p_{s}$) of predicates (i.e. $p_{e}$ and $p_{s}$) for asserting equivalence or specialization relations among properties:

:subProperty rdfs:subPropertyOf rdfs:subPropertyOf. :subClass :subProperty rdfs:subClassOf. :y :subClass :x.

Although there exist alternative ways for asserting an equivalence (specialization) relation between two entities $e_{1}$ and $e_{2}$ (e.g., $e_{1}=e_{2}\sqcap\exists p.\top$ implies $e_{1}\sqsubseteq e_{2}$), we focused on the most explicit ones, namely, those in which $e_{1}$ and $e_{2}$ are connected by a path having as edges $p_{eq}$ ($p_{sub}$) or properties that are equivalent or subsumed by $p_{eq}$ (called Closure Path cf. Definition 2). We argue that for statistical observations explicit assertions provide acceptable approximations of the overall picture.

Figure 1 shows an example of an RDF Knowledge Graph (Subfigure 1(a)). The equivalence predicate ($p_{eq}$) is owl:equivalentClass; the specialization predicate ($p_{sub}$) is rdfs:subClassOf, the property for asserting equivalences among predicates ($p_{e}$) is owl:equivalentProperty, the property for asserting specializations among predicates ($p_{s}$) is (rdfs:subPropertyOf). The corresponding Equivalence Set Graph (Subfigure 1(b)) contains four equivalence sets. The top node represents the agent node, which encapsulates entities in DOLCE and W3C’s Organization ontology. Three nodes inherit from the agent node. Two nodes contain classes that specialize dul:Agent in the DOLCE ontology (i.e. dul:PhysicalAgent and dul:SocialAgent). The third node represents the person concept, which encapsulates entities in DBpedia, DOLCE, and FOAF. The equivalence of these classes is asserted by owl:equivalentClass and :myEquivalentClass. Since foaf:Person specialises org:Agent (using :mySubClassOf which specialises rdfs:subClassOf) and dul:Person specialises dul:Agent the ESG contains an edge between the person and the agent concept.

3.3 Formalizing Equivalence Set Graphs

This section contains the formalization of ESGs that were informally introduced above. An ESG must be configured with ground terms for the following parameters:

(i) $p_{eq}$: the equivalence property for the observed entities;

(ii) $p_{sub}$: the specialization property for the observed entities;

(iii) $p_{e}$the equivalence property for properties;

(iv) $p_{s}$the specialization property for properties.

Definition 1 specifies the deductive closure over an arbitrary property $p$ with respect to $p_{e}$ and $p_{s}$. This is the set of properties that are implicitly equivalent to or subsumed by $p$. It is worth noticing that, in the general case, a deductive closure for a class of (observed) entities depends on all the four parameters: $p_{eq}$ and $p_{sub}$ are needed for retrieving equivalences and specializations among entities, and $p_{e}$ and $p_{s}$ are need for retrieving equivalences and specializations of $p_{eq}$ and $p_{sub}$. It is easy to see that when the subject of observation are properties $p_{eq}$ and $p_{sub}$ coincide with $p_{e}$ and $p_{s}$ respectively.

Definition 1 (Deductive Closure of Properties)

$\overline{\mathcal{C}\begin{subarray}{c}p_{e},p_{s}\\ p_{e},p_{s}\end{subarray}}(p)$ is the deductive closure of property $p$ with respect to $p_{e}$ and $p_{s}$.

Definition 2 (Closure Path)

$\begin{subarray}{c}p+\\ \Longleftrightarrow\end{subarray}$ denotes any path, consisting of one or more occurrences of predicates from $\overline{\mathcal{C}\begin{subarray}{c}p_{e},p_{s}\\ p_{e},p_{s}\end{subarray}}(p)$.

Once the four custom parameters have been specified, a specific Equivalence Set Graph is determined by Definitions 3 and 4.

Definition 3 (ESG Nodes)

Let $G$ be the graph merge [10] of an RDF Knowledge Graph. The set of nodes of the corresponding Equivalence Set Graph is:

[TABLE]

Definition 4 (ESG Edges)

Let $G$ be the graph merge of an RDF Knowledge Graph. The set of edges of the corresponding Equivalence Set Graph is:

[TABLE]

Definitions 5 and 6 define the concept of closure.

Definition 5 (Specialization Closure)

Let $G$ be the graph merge of an RDF Knowledge Graph. The specialization closure of $G$ is a function that maps an entity $e$ onto the set of entities that implicitly specialise $e$:

[TABLE]

Definition 6 (Equivalence and Specialization Closure)

Let G be a graph merge of an RDF Knowledge Graph, the equivalence and specialization closure of $G$ is a function that given an entity e returns all the entities that are either implicitly equivalent to e, or implicitly specialize e. I.e.:

[TABLE]

3.4 Metrics

In this section we define a set of metrics that can be computed by querying Equivalence Set Graphs.

Number of equivalence sets (ES), Number of observed entities (OE), and Ratio (R). The number of equivalence sets (ES) is the number of nodes in an Equivalence Set Graph, i.e., $|\mathcal{V}\begin{subarray}{c}p_{eq},p_{sub}\\ p_{e},p_{s}\end{subarray}|$. Equivalence sets contain equivalent entities (classes, properties or individuals). The number of observed entities (OE) is the size of the universe of discourse: i.e. $|\{e\in v\,|\,v\in\mathcal{V}\begin{subarray}{c}p_{eq},p_{sub}\\ p_{e},p_{s}\end{subarray}\}|$. The ratio $\frac{ES}{OE}$ (R) between the number of equivalence sets and the number of entities indicates to what extent equivalence is used among the observed entities. If equivalence is rarely used, R approaches 1.0.

Number of edges (E) The total number of edges is $|\mathcal{E}\begin{subarray}{c}p_{eq},p_{sub}\\ p_{e},p_{s}\end{subarray}|$.

Height of Nodes. The height $h(v)$ of a node $v$ is defined as the length of the longest path from a leaf node until $v$. The maximum height of an ESG is defined as $H_{max}=\operatorname*{argmax}_{v\in V}h(v)$. Distribution of the height: for n ranging from 0 to $H_{max}$ we compute the percentage of nodes having that height (i.e. H(n)).

Number of Isolated Equivalent Sets (IN), Number of Top Level Equivalence Sets (TL). In order to observe the shape and structure of hierarchies in LOD, we compute the number Isolated Equivalent Sets (IN) in the graph, and the number of Top Level Equivalence Sets (TL). An IES is a node without incoming or outgoing edges. A TL is a node without outgoing edges.

Extensional Size of Observed Entities. Let $c$ be a class in LOD, and $t$ a property in the deductive closure of rdf:type. We define the extensional size of $c$ (i.e. $S(c)$) as the number of triples having $c$ as object and $t$ as predicate (i.e. $S(c)=\sum_{t\in\overline{\mathcal{C}\begin{subarray}{c}\\ \end{subarray}}}|\{\langle e,t,c\rangle|\exists e.\langle e,t,c\rangle\in G\}|$ where $\overline{\mathcal{C}\begin{subarray}{c}\\ \end{subarray}}$ is $\overline{\mathcal{C}\begin{subarray}{c}p_{e},p_{s}\\ p_{e},p_{s}\end{subarray}}$). We define the extensional size of a property $p$ (i.e. $S(p)$) as the number of triples having $p$ as predicate (i.e. $S(p)=|\{\langle s,p,o\rangle|\exists p,o.\langle s,p,o\rangle\in G\}|$).

Extensional Size of Equivalence Sets. We define two measures: direct extensional size (i.e. DES) and indirect extensional size (i.e. IES). DES is defined as the sum of the extensional size of the entities belonging to the set. The IES is its DES summed with the DES of all equivalence sets in its closure.

Number of Blank Nodes. Blank nodes are anonymous RDF resource used (for example) within ontologies to define class restrictions. We compute the number of blank nodes in LOD and we compute the above metrics both including and excluding blank nodes.

Number of Connected Components. Given a directed graph G, a strongly connected component (SCC) is a sub-graph of G where any two nodes are connected to each other by at least one path; a weakly connected component (WCC) is the undirected version of a sub-graph of G where any two nodes are connected by any path. We compute the number and the size of SCC and WCC of an ESG, to observe its distribution. Observing these values (especially on WCC) provides insights on the shape of hierarchical structures formed by the observed entities, at LOD scale.

4 Computing Equivalence Set Graphs

In this Section we describe the algorithm for computing an equivalence set graph from a RDF dataset. An implementation of the algorithm is available online555https://w3id.org/edwin/repository.

Selecting Entities to Observe. The first step of the procedure for computing an ESG is to select the entities to observe, from the input KG. To this end, a set of criteria for selecting these entities can be defined. In our study we want to observe the behaviour of classes and properties, hence our criteria are the followings:

(i) A class is an entity that belongs to rdfs:Class. We assume that the property for declaring that an entity belongs to a class is rdf:type.

(ii) A class is the subject (object) of a triple where the property has rdfs:Class as domain (range). We assume that the property for declaring the domain (range) of a property is rdfs:domain (rdfs:range).

(iii) A property is the predicate of a triple.

(iv) A property is an entity that belongs to rdf:Property.

(v) A property is the subject (object) of a triple where the property has rdf:Property as domain (range).

We defined these criteria since the object of our observation are classes and properties, but the framework can be also configured for observing other kinds of entities (e.g. individuals).

As discussed in Section 3.2 we have to take into account possible equivalences and/or specializations of the ground terms, i.e. rdf:type, rdfs:range, rdfs:domain and the classes rdfs:Class and rdf:Property.

Computing Equivalence Set Graph. As we saw in the previous section, for computing an ESG a preliminary step is needed in order to compute the deductive closure of properties (which is an ESG itself). We can distinguish two cases depending if condition $p_{eq}=p_{e}$ and $p_{sub}=p_{s}$ holds or not. If this condition holds (e.g. when the procedure is set for computing the ESG of properties), then for retrieving equivalences and specializations of $p_{eq}$ and $p_{sub}$ the procedure has to use the ESG is building (cf. UpdatePSets). Otherwise, the procedure has to compute an ESG (i.e. $\overline{\mathcal{C}\begin{subarray}{c}p_{e},p_{s}\\ p_{e},p_{s}\end{subarray}}$) using $p_{e}$ as $p_{eq}$ and $p_{s}$ as $p_{sub}$. We describe how the algorithm works in the first case (in the second case, the algorithm acts in a similar way, unless that $P_{e}$ and $P_{s}$ are filled with $\overline{\mathcal{C}\begin{subarray}{c}p_{e},p_{s}\\ p_{e},p_{s}\end{subarray}}$($p_{eq}$) and $\overline{\mathcal{C}\begin{subarray}{c}p_{e},p_{s}\\ p_{e},p_{s}\end{subarray}}$($p_{sub}$) respectively and UpdatePSets is not used).

The input of the main procedure (i.e. Algorithm 1) includes:

(i) a set $P_{e}$ of equivalence relations. In our case $P_{e}$ will contain owl:equivalentProperty for the ESG of properties, and (the deductive closure of) owl:equivalentClass for the ESG of classes;

(ii) a set $P_{s}$ of specialisation relations. In our case $P_{s}$ will contain rdfs:subPropertyOf for the ESG of properties, and (the deductive closure of) rdfs:subClassOf for the ESG of classes.

The output of the algorithm is a set of maps and multi-maps which store nodes and edges of the computed ESG:

ID

a map that, given an IRI of an entity, returns the identifier of the ES it belongs to;

IS

a multi-map that, given an identifier of an ES, returns the set of entities it contains;

H ($H^{-}$)

a multi-map that, given an identifier of an ES, returns the identifiers of the explicit super (sub) ESs.

The algorithm also uses two additional data structures:

(i) $P^{\prime}_{e}$is a set that stores the equivalence relations already processed (which are removed from $P_{e}$ as soon as they are processed);

(ii) $P^{\prime}_{s}$is a set that stores the specialisations relations already processed (which are removed from $P_{s}$ as soon as they are processed).

The algorithm repeats three sub-procedures until $P_{e}$ and $P_{s}$ become empty:

(i) Compute Equivalence Sets (Algorithm 2),

(ii) Compute the Specialisation Relation among the Equivalence Sets (Algorithm 4),

(iii) Update $P_{e}$ and $P_{s}$ (i.e. UpdatePSets).

Algorithm 2 iterates over $P_{e}$, and at each iteration moves a property $p$ from $P_{e}$ to $P^{\prime}_{e}$, until $P_{e}$ is empty. For each triple $\langle r_{1},p,r_{2}\rangle\in G$, it tests the following conditions and behaves accordingly:

$r_{1}$ and $r_{2}$ do not belong to any ES, then: a new ES containing $\{r_{1},r_{2}\}$ is created and assigned an identifier i. ($r_{1}$,i) and ($r_{2}$,i) are added to ID, and (i, $\{r_{1},r_{2}\}$) to IS; 2. 2.

$r_{1}$ ($r_{2}$) belongs to the ES with identifier $i_{1}$ ($i_{2}$) and $r_{2}$ ($r_{1}$) does not belong to any ES. Then ID and IS are updated to include $r_{2}$ ($r_{1}$) in $i_{1}$ ($i_{2}$); 3. 3.

$r_{1}$ belongs to an ES with identifier $i_{1}$ and $r_{2}$ belongs to an ES with identifier $i_{2}$ (with $i_{1}\neq i_{2}$). Then $i_{1}$ and $i_{2}$ are merged into a new ES with identifier $i_{3}$ and the hierarchy is updated by Algorithm 3. This algorithm ensures both the followings:

(i) the super (sub) set of $i_{3}$ is the union of the super (sub) sets of $i_{1}$ and $i_{2}$;

(ii) the super (sub) sets that are pointed by (points to) (through $H$ or $H^{-}$) $i_{1}$ or $i_{2}$, are pointed by (points to) $i_{3}$ and no longer by/to $i_{1}$ or $i_{2}$.

The procedure for computing the specialization (i.e. Algorithm  4) moves p from $P_{s}$ to $P^{\prime}_{s}$ until $P_{s}$ becomes empty. For each triple $\langle r_{1},p,r_{2}\rangle\in G$ the algorithm ensures that $r_{1}$ is in an equivalence set with identifier $i_{1}$ and $r_{2}$ is in an equivalence set with identifier $i_{2}$:

If $r_{1}$ and $r_{2}$ do not belong to any ES, then IS and ID are updated to include two new ESs $\{r_{1}\}$ with identifier $i_{1}$ and $\{r_{2}\}$ with identifier $i_{2}$; 2. 2.

if $r_{1}$ ($r_{2}$) belongs to an ES with identifier $i_{1}$ ($i_{2}$) and $r_{2}$ ($r_{1}$) does not belong to any ES, then IS and ID are updated to include a new ES $\{r_{2}\}$ ($\{r_{1}\}$) with identifier $i_{2}$ ($i_{1}$).

At this point $r_{1}$ is in $i_{1}$ and $r_{2}$ is in $i_{2}$ ($i_{1}$ and $i_{2}$ may be equal) and then $i_{2}$ is added to $H(i_{1})$ and $i_{1}$ is added to $H^{-}(i_{2})$.

The procedure UpdatePSets (the last called by Algorithm 1) adds to $P_{e}$ ($P_{s}$) the properties in the deductive closure of properties in $P^{\prime}_{e}$ ($P^{\prime}_{s}$). For each property p in $P^{\prime}_{e}$ ($P^{\prime}_{s}$), UpdatePSets uses ID to retrieve the identifier of the ES of p, then it uses $H^{-}$ to traverse the graph in order retrieve all the ESs that are subsumed by ID(p). If a property $p^{\prime}$ belongs to ID(p) or to any of the traversed ESs is not in $P^{\prime}_{e}$ ($P_{s}$), then $p^{\prime}$ is added to $P_{e}$ ($P_{s}$).

Algorithm Time Complexity. Assuming that retrieving all triples having a certain predicate and inserting/retrieving values from maps costs O(1). The algorithm steps once per each equivalence or subsumption triple. FixHiearchy costs in the worst case O($n_{eq}$) where $n_{eq}$ is the number of equivalence triples in the input dataset. $n_{sub}$ is the number of specialization triples in the input dataset. Hence, time complexity of the algorithm is O($n_{eq}^{2}$ + $n_{sub}$).

Algorithm Space Complexity. In the worst case the algorithm needs to create an equivalence set for each equivalence triple and a specialization relation for each specialization triple. Storing ID and IS maps costs $\sim$2n (where n is the number of observed entities from the input dataset), whereas storing H and $H^{-}$ costs $\sim 4n^{2}$ . Hence, the space complexity of the algorithm is O($n^{2}$).

5 Results

In order to analyse the modeling structure and style of LOD we compute two ESGs from LOD-a-lot: one for classes and one for properties. Both graphs are available for download666https://w3id.org/edwin/iswc2019_esgs. We used a laptop (3Ghz Intel Core i7, 16GB of RAM). Building the two ESGs took $\sim$11 hours, computing their extension took $\sim$15 hours. Once the ESG are built, we can query them to compute the metrics defined in 3.4 and make observations at LOD scale within the order of a handful of seconds/minutes. Queries to compute indirect extensional dimension may take longer, in our experience up to 40 minutes.

The choice of analysing classes and properties separately reflects the distinctions made by RDF(S) and OWL models. However, this distinction is sometimes overlooked in LOD ontologies. We observed the presence of the following triples:

rdfs:subPropertyOf rdfs:domain rdf:Property . # From W3C rdfs:subClassOf rdfs:domain rdfs:Class . # From W3C rdfs:subClassOf rdfs:subPropertyOf rdfs:subPropertyOf . # From BTC

The first two triples come from RDFS vocabulary defined by W3C, and the third can be found in the Billion Triple Challenge datasets777https://github.com/timrdf/DataFAQs/wiki/Billion-Triples-Challenge. These triples imply that if a property $p_{1}$ is subsumed by a property $p_{2}$, then $p_{1}$ and $p_{2}$ become classes. Since our objective is to observe classes and property separately we can not accept the third statement. For similar reasons, we can not accept the following triple:

rdf:type rdfs:subPropertyOf rdfs:subClassOf . # From BTC

which implies that whatever has a type becomes a class. It is worth noticing that these statements does not violate RDF(S) semantics, but they do have far-reaching consequences for the entire Semantic Web, most of which are unwanted.

Equivalence Set Graph for Properties. We implemented the algorithm presented in Section 4 to compute the ESG for properties contained in LOD-a-lot [7]. Our input parameters to the algorithm are:

(i) P_{eq}$$={owl:equivalentProperty};

(ii) P_{s}$$={rdfs:subPropertyOf}.

Since owl:equivalentProperty is neither equivalent to nor subsumed by any other property in LOD-a-lot, the algorithm used only this property for retrieving equivalence relations. Instead, for computing the hierarchy of equivalence sets the algorithm used 451 properties which have been found implicitly equivalent to or subsumed by rdfs:subPropertyOf.

Table 1 presents the metrics (cf. Section 3.4) computed from the equivalence set graph for properties. It is quite evident that the properties are poorly linked.

(i) The ratio (R) tends to 1, indicating that few properties are declared equivalent to other properties;

(ii) the ratio between the number of equivalence sets (ES) and the number of isolated sets (IN) is 0.88, indicating that most of properties are defined outside of a hierarchy;

(iii) the height distribution of ESG nodes (cf. Figure 2(a)) shows that all the nodes have height less than 1;

(iv) the high number of Weakly Connected Components (WCC) is close to the total number of ES.

Figure 2(c) shows that the dimension of ESs follows the Zipf’s law (a trend also observed in [6]): many ESs with few instances and few ESs with many instances. Most properties ($\sim$90%) have at least one instance. This result is in contrast with one of the findings of Ding and Finin in 2006 [4] who observed that most properties have never been instantiated. We note that blank nodes are present in property hierarchies, although they cannot be instantiated. This is probably due to some erroneous statement.

Equivalence Set Graph for Classes. From the ESG for properties we extract all the properties implicitly equivalent to or subsumed by owl:equivalentClass (2 properties) and put them in $P_{eq}$, the input parameter of the algorithm. $P_{s}$ includes 381 properties that are implicitly equivalent to or subsumed by rdfs:subClassOf.

Table 1 reports the metrics (cf. Section 3.4) computed from the ESG for classes. Although class equivalence is more common than property equivalence, the value of R is still very high (0.83), suggesting that equivalence relations among classes are poorly used. Differently from properties, classes form deeper hierarchies: the maximum height of a node is 77 (compared to 14 for properties), only 7% of nodes are isolated and only 31% are top level nodes, we observe from Figure 2(a) that the height distribution has a smoother trend than for properties but still it quickly reaches values slightly higher than 0. We observe that (unlike properties) most of class ES are not instantiated: only 31.7% of ES have at least one instance. A similar result emerges from the analysis carried out in 2006 by Ding and Finin [4] who reported that 95% of semantic web terms (properties and classes) have no instances (note that in [4] no RDFS and OWL inferencing was done). It is worth noticing that part (800K) of these empty sets contain only black node that cannot be directly instantiated. As for properties, the dimension of ES follows the Zipf’s distribution (cf. Figure 2(d)), a trend already observed in the early stages of the Semantic Web [4]. We also note that blank nodes are more frequent in class hierarchies than in property hierarchies (25% of ES of classes contain at least one blank node).

6 Discussion

We have presented an empirical study aiming at understanding the modeling style and the overall semantic structure of the Linked Open Data cloud. We observed how classes, properties and individuals are used in practice, and we also investigated how hierarchies of concepts are structured, and how much they are linked.

Even if our conclusions on the issues with LOD data are not revolutionarily (the community is in general aware of the stated problems for Linked Data), we have presented a framework and concrete metrics to obtain concrete results that underpin these shared informal intuitions. We now briefly revisit our main findings:

LOD ontologies are sparsely interlinked. The values computed for metric R (ratio between ES and OE) tell us that LOD classes and properties are sparsely linked with equivalence relations. We can only speculate as to whether ontology linking is considered less important or more difficult than linking individuals, or wether the unlinked classes belong to very diverse domains. However, we find a high value for metric TL (top level ES) with an average of $\sim$ 1.1 classes per ES. Considering that the number of top level classes (without counting BN) is $\sim$348k, it is reasonable to suspect a high number of conceptual duplicates. The situation for properties is even worse: the average number of properties per TL ES is 1 and the number of top level properties approximates their total number.

LOD ontologies are also linked by means of specialisation relations (rdfs:subClassOf and rdfs:subPropertyOf). Although the situation is less dramatic here, it confirms the previous finding. As for properties, $\sim$88.7% of ES are isolated (cf. IN). Classes exhibit better behaviour in this regard, with only 7% of isolated classes. This confirms that classes are more linked than properties, although mostly by means of specialisation relations.

LOD ontologies are mostly flat. The maximum height of ESG nodes is 14 for properties and 77 for classes. Their height’s distribution (Figure 2(a)) shows that almost all ES ($\sim$ 100%) belong to flat hierarchies. This observation, combined with the values previously observed (cf. IN and R), reinforces the claim that LOD must contain a large number of duplicate concepts.

As for classes, $\sim$50% of ES have no specialising concepts, i.e., height=0 (Figure 2(a)). However, a bit less than the remaining ES have at least one specialising ES. Only a handful of ES reach up to 3 hierarchical levels. The WCC distribution (Figure 2(b)) confirms that classes in non-flat hierarchies are mostly organised as siblings in short-depth trees. We speculate that ontology engineers put more care into designing their classes than they put in designing their properties.

LOD ontologies contain many uninstantiated concepts. We find that properties are mostly instantiated ($\sim$90%), which suggests that they are defined in response to actual need. However, most classes – even not counting blank nodes – have no instances: $\sim$ 67% of TL ES have no instances. A possible interpretation is that ontology designers tend to over-engineer ontologies beyond their actual requirements, with overly general concepts.

6.1 Future work

We are working on additional metrics that can be computed on ESGs, and on extending the framework to analyse other kinds of relations (e.g. disjointness). We are also making a step towards assessing possible relations between the domain of knowledge addressed by LOD ontologies and the observations made.