The Semantic Web & Linked Data

[Cover of Scientific American, May 2001] — ©2001 Scientific American

The Semantic Web isn’t just about putting data on the Web. It is about making links, so that a person or machine can explore the Web of Data.
With Linked Data, when you have some of it,
you can find other, related, data.
Tim Berners-Lee

The Semantic Web is a layer
on top of the existing Web.

The Semantic Web layer is integrated
into the existing Web.

Tim Berners-Lee proposed
4 principles to publish Linked Data.

Use URIs as names for things.
Use HTTP URIs so people
can look up those names.
When someone looks up a URI,
provide useful information using the standards.
Include links to other things,
so people can discover more.

The Linked Data principles resemble
the REST uniform interface constraints.

Uniquely identify resources.
Provide representations
of those resources to clients.
Each message you send
should be self-describing.
Hypermedia controls
must afford next steps.

Information & non-information resources
should be uniquely identifiable.

Pointing to resources with a common name
or description is often ambiguous.
- “the” protocol of the Web (which?)
- Dan Connolly (who?)
- …
Reuse or mint an IRI for them.
- urn:ietf:rfc:7230
- https://en.wikipedia.org/wiki/Dan_Connolly_(computer_scientist)
- …
Especially machines need unambiguous identifiers.

Using HTTP URIs ensures that
anybody can look up the resource.

An HTTP URI of a resource can be dereferenced:
use an HTTP client to retrieve a representation.
- Information resources result in a representation.
- Non-information resources result in a 303 redirect.
This relies on the double role of an HTTP URI
as identifier and locator.
Dereferencing is a core principle of Linked Data.
- If you don’t know something, look it up. Follow your nose.

Dereferencing a URI should lead to
useful information about that resource.

“Useful” means the information is available
using standard technologies.
- Tim Berners-Lee mentions RDF and SPARQL.
“Useful” also means the information provides
explanations and/or context for the resource.
Define the resource in terms of concepts
the client already knows or can look up.

By including links to other resources,
we create a Web of Data.

Links connect a resource to known concepts.
- Marissa is a key person within Yahoo Inc.
Links give meaning to data.
- These temperatures are measured in degrees Celsius.
Links allow exploration of related data.
- Find more by the same author.

The basic information unit in Linked Data
is a link from one resource to another.

Those two resources each
are identified by an HTTP URI.

To simplify their display,
we abbreviate URIs using prefixes.

In contrast to typical Web links, these links
are typed with a URI we can dereference.

This means that a link type (property)
is also a resource we can describe.

In addition to resources,
link targets can also be literal values.

By linking resources together this way,
we create a Web of Linked Data.

Prefixes are a convention,
so they can be chosen freely.

prefix.cc lists several common ones:

rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
rdfs: http://www.w3.org/2000/01/rdf-schema#
owl: http://www.w3.org/2002/07/owl#
foaf: http://xmlns.com/foaf/0.1/
dbr: http://dbpedia.org/resource/
dbo: http://dbpedia.org/ontology/

Additionally, we will use ex for examples.

An immense amount of Linked Data
is available on the Web for reuse.

On the structural level, hundreds of vocabularies
can provide the building blocks to model your data.
- They provide properties and classes to reuse.
- Although not always counted as Linked Data
  because of their small size, most follow all 4 principles.
On the content level, thousands of datasets
provide identifiers and data of individuals.
- Strive to reuse identifiers rather than to mint new ones.

No Linked Data set is ever complete.
We make the open-world assumption.

Relational databases use highly rigid structures.
They strive for complete data.
- A NULL value can signal missing data,
  but this is typically an undesired situation.
With Linked Data, no source has all of the truth.
Other sources might have more data on a subject.
- The absence of a fact does not imply its falsehood.
- A fact has 2 possible states: true and unknown.

Several vocabularies are used frequently
across different datasets.

modeling vocabularies
- RDFS
- OWL
- SKOS
general-purpose vocabularies
- Dublin Core
- …
concept-specific vocabularies
- Schema.org
- Open Graph
- DBpedia ontology
- …

Find the one you need at Linked Open Vocabularies.

The Dublin Core terms are a set of
15 common metadata properties.

Each property is generic,
and hence applicable in many cases.
- title
- description
- date
- creator
- …
Many applications use the Dublin Core terms.
- good interoperability of high-level semantics

Schema.org is a single vocabulary
that covers many different fields.

Created and maintained by major search engines,
it mainly provides discovery data for search.
Its concepts are defined rather loosely.
- This makes it flexible to use for developers.
- Machines cannot derive much knowledge from it.
Schema.org is manually curated
and open for extension.

Billions of Linked Data facts are published
on the Web with an open license.

The most well-known dataset is DBpedia.
- Data is extracted automatically from Wikipedia infoboxes.
- Like Wikipedia, it exists in several different languages.
- Its quality is acceptable for many queries.
Wikidata is a manually curated alternative.
- It has its own data model on top of RDF.
- It grows fast and might overtake DBpedia.
You can find many other datasets on Datahub.

The Resource Description Framework is
a model for data interchange on the Web.

RDF is a standardized way to represent Linked Data.
The RDF model defines RDF datasets.
- An RDF dataset has a default graph and ≥ 0 named graphs.
- An RDF graph is a set of RDF triples.
- An RDF triple consists of a subject, predicate, and object.
RDF has different concrete syntaxes.
- triple-based
- JSON-based
- XML-based

This Linked Data fact can be
represented as an RDF triple.

We define the triple by its components:

subject: IRI – dbr:Tim_Berners-Lee
predicate: IRI – foaf:knows
object: IRI – dbr:Ted_Nelson

There are 3 types of RDF terms:
named nodes, blank nodes, and literals.

Triples consist of RDF terms as follows:

named node: a resource, identified by an IRI; for subjects, predicates, objects
blank node: an unnamed resource; for subjects and objects
literal: a value, with a datatype (IRI) or language; for objects only

This RDF triple has
a literal as an object.

We define the triple by its components:

subject: IRI – dbr:Tim_Berners-Lee
predicate: IRI – foaf:givenName
object: literal – Tim with language en

This RDF triple has
a literal as an object.

We define the triple by its components:

subject: IRI – dbr:Tim_Berners-Lee
predicate: IRI – dbo:birthDate
object: literal – 1955-06-08
with datatype xsd:date

This is an RDF graph
consisting of a set of triples.

An RDF dataset has one default graph
and zero or more named graphs.

The default graph is an RDF graph.
- It can be empty.
A named graph is an RDF graph identified by an IRI.
- A triple belongs to one or more graphs.
- A triple with graph is sometimes called a quad.
Not all concrete syntaxes support named graphs.
- All syntaxes support the default graph.

Several standard syntaxes for RDF exist.
Some of them have multi-graph support.

independent syntaxes

triple-based

N-Triples

Turtle

N-Quads

TriG

JSON-based

JSON-LD

XML-based

RDF/XML
embeddable syntaxes

for HTML/XML

RDFa

N-Triples is a line-based syntax
supporting only a default graph.

# Every non-empty line represents a triple or comment.
# IRIs are enclosed in angular brackets (< and >).
<http://dbpedia.org/resource/Tim_Berners-Lee> <http://xmlns.com/foaf/0.1/knows> <http://dbpedia.org/resource/Ted_Nelson>.
# Literals are enclosed in double quotation marks (")
# and optionally end with @ and a language tag.
<http://dbpedia.org/resource/Tim_Berners-Lee> <http://xmlns.com/foaf/0.1/givenName> "Tim"@en.
# Alternatively, they end with ^^ and a datatype IRI.
<http://dbpedia.org/resource/Tim_Berners-Lee> <http://dbpedia.org/ontology/birthDate> "1955-06-08"^^<http://www.w3.org/2001/XMLSchema#date>.

Turtle is a superset of N-Triples
with prefixes and abbreviations.

# Declare prefixes before use (hint: prefix.cc).
PREFIX dbr: <http://dbpedia.org/resource/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
# The predicate a abbreviates rdf:type.
# A semi-colon ; reuses the subject.
# A comma , reuses the subject and predicate.
dbr:Tim_Berners-Lee a foaf:Person;
                    foaf:knows dbr:Ted_Nelson,
                               dbr:Wendy_Hall.
# There are 3 triples above.

Turtle includes syntactic sugar
to write blank nodes.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
# The following lines all state something is named Tim.
_:x235 foaf:name "Tim"@en.  # blank node label
[] foaf:name "Tim"@en.      # empty blank node
[ foaf:name "Tim"@en ].     # blank node with properties
# Something named Tim knows something named Wendy.
[ foaf:name "Tim"@en ] foaf:knows [ foaf:name "Wendy"@en ].

# The label-based syntax allows cross-references within
# the same document, and is also supported in N-Triples.

Turtle includes syntactic sugar
to write (head/tail) lists.

PREFIX ex: <http://example.org/>
# Note also a shorthand for writing numbers.
ex:MyLottery ex:luckyNumbers (5 14 15).
# This corresponds to:
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
ex:MyLottery ex:luckyNumbers _:list1.
_:list1 rdf:first "5"^^xsd:integer
_:list1 rdf:next  _:list2.
_:list2 rdf:first "14"^^xsd:integer
_:list2 rdf:next  _:list3.
_:list3 rdf:first "15"^^xsd:integer
_:list3 rdf:next  rdf:nil.

N-Quads is a superset of N-Triples
with support for named graphs.

# Triples in the default graph look like N-Triples.
<urn:ex:s1> <urn:ex:p1> <urn:ex:o1>.
<urn:ex:s1> <urn:ex:p2> "abc".

# Triples in named graphs have a fourth element.
<urn:ex:s2> <urn:ex:p1> <urn:ex:o2> <urn:ex:GraphA>.
<urn:ex:s2> <urn:ex:p2> "xyz" <urn:ex:GraphB>.

TriG is a superset of Turtle (not N-Quads)
with support for named graphs.

PREFIX dbr: <http://dbpedia.org/resource/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
# Triples in the default graph look like Turtle.
dbr:Tim_Berners-Lee a foaf:Person;
                    foaf:knows dbr:Ted_Nelson.
# Named graphs are indicated by a graph statement.
<http://example.org/graphs/Fiction> {
    dbr:Clark_Kent a foaf:Person;
                     foaf:nick "Superman"@en.
}

JSON-LD is a JSON syntax to represent
an RDF dataset, supporting named graphs.

Each document points to a JSON-LD context,
creating meaning by mapping JSON terms to IRIs.
- It is linked either from the JSON document with @context
- or outside of the document through an HTTP Link header.
The @id keyword points to an identifier
for a resource (represented by a JSON object).
- This explicitly identifies resources with an IRI
  (for cases where none was provided by the context).

JSON-LD provides additional interpretation
on top of the JSON specification.

A JSON-LD document can be interpreted as
a plain JSON document or as RDF graphs & triples.
- easy for developers: no RDF awareness needed
- easy for machines: data has well-defined semantics
To allow for this interpretation,
the document must be served correctly.
- application/json with HTTP Link context: JSON-LD
- application/ld+json with @context key: JSON-LD
- all other JSON documents: not JSON-LD

JSON-LD documents look almost
like regular JSON documents.

{
  "@context": "http://schema.org/",
  "@id": "http://dbpedia.org/resource/Tim_Berners-Lee",
  "givenName": "Tim",
  "knows": [{
    "@id": "http://dbpedia.org/resource/Ted_Nelson",
    "givenName": "Ted"
  }]
}

JSON-LD documents can be approached
like regular JSON documents.

{
  "@context": "http://schema.org/",
  "@id": "http://dbpedia.org/resource/Tim_Berners-Lee",
  "givenName": "Tim",
  "knows": [{
    "@id": "http://dbpedia.org/resource/Ted_Nelson",
    "givenName": "Ted"
  }]
}

JSON-LD documents can be approached
as RDF triples (or quads).

# These triples are equivalent to the JSON-LD example.
PREFIX dbr: <http://dbpedia.org/resource/>
PREFIX schema: <http://schema.org>

dbr:Ted_Nelson schema:givenName "Ted".
dbr:Tim_Berners-Lee schema:givenName "Tim";
                    schema:knows dbr:Ted_Nelson.

The XML-based syntax for RDF
represents triples, but not named graphs.

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:schema="http://schema.org/">
  <rdf:Description rdf:about="http://dbpedia.org/resource/Ted_Nelson">
    <schema:givenName>Ted</schema:givenName>
  </rdf:Description>
  <rdf:Description rdf:about="http://dbpedia.org/resource/Tim_Berners-Lee">
    <schema:givenName>Tim</schema:givenName>
    <schema:knows rdf:resource="http://dbpedia.org/resource/Ted_Nelson"/>
  </rdf:Description>
</rdf:RDF>

Choose the right RDF syntax based on
graph support and client technology.

RDFa allows extending generic HTML
and XML documents with RDF triples.

Instead of performing content negotiation,
RDFa embeds triples inside other formats.
- One representation can be interpreted
  by multiple types of clients.
RDFa extends existing markup with new attributes.

This RDFa example interleaves
HTML markup with RDF triples.

<div vocab="http://xmlns.com/foaf/0.1/" typeof="Person">
  <p>
    <span property="name">Alice Birpemswick</span>,
    (<a property="mbox" href="mailto:alice@example.com">alice@example.com</a>)
  </p>
  <ul>
    <li property="knows" typeof="Person">
      <a property="homepage" href="https://example.com/bob/">Bob</a>
    </li>
    <li property="knows" typeof="Person" resource="https://example.com/people/#eve">
      <span property="name">Eve</span>
    </li>
  </ul>
</div>

The extracted RDFa data is regular RDF
that can be converted to other formats.

[] a foaf:Person;
   foaf:name "Alice Birpemswick".
   foaf:mbox <mailto:alice@example.com>;
   foaf:knows [ a foaf:Person;
                foaf:homepage <https://example.com/bob/> ],
              <https://example.com/people/#eve>;

<https://example.com/people/#eve> a foaf:Person;
    foaf:name "Eve".

RDF on the Web can be found in webpages
and through content negotiation.

Many pages mark up their data
to improve indexing of their content.
- The Internet Movie Database marks up movies
  with RDFa and Microdata (example).
Linked Data documents typically provide
multiple RDF representations per resource.
- DBpedia pages are available in HTML + RDF,
  Turtle, JSON-LD, and RDF/XML (example).

RDF Schema is an RDF vocabulary
to model RDF vocabularies.

RDFS defines classes, properties, and datatypes
that are used to define vocabularies.
- The RDFS vocabulary has a human-readable specification.
- It also has a machine-readable vocabularies,
  which define RDFS in terms of RDFS.
RDFS defines concepts in two namespaces.
- rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
- rdfs: http://www.w3.org/2000/01/rdf-schema#

Practitioners in the RDF world often
refer to vocabularies as ontologies.

Strictly speaking, a vocabulary is a set of words;
an ontology a set of concepts and their relations.
The W3C states that there is “no clear division”.

vocabulary

usually in less formal contexts

ontology

usually in more complex and/or formal contexts
These slides use both terms interchangeably.

RDFS defines the basic building blocks
to construct RDF vocabularies.

describing resources
- rdfs:label
- rdfs:comment
- rdfs:seeAlso
- …
describing classes
- rdf:type
- rdfs:Resource
- rdfs:Class
- rdfs:Literal
- rdf:Property
- rdfs:subClassOf
- …
describing properties
- rdfs:domain
- rdfs:range
- rdfs:subPropertyOf
- …

`rdfs:label` is a property that gives
a human-readable name to a resource.

Resources typically have ≤ 1 label per language.
- However, rdfs:label is not a functional property.

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

foaf:knows rdfs:label "knows"@en, "kent"@nl, "connaît"@fr.

rdfs:label rdfs:label "label"@en.

`rdfs:comment` is a property that clarifies
human-readable meaning and usage.

Resources typically have ≤ 1 comment per language.
- However, rdfs:comment is not a functional property.

# rdf, rdfs, and foaf prefixes omitted for brevity
foaf:knows rdfs:label "knows"@en;
           rfds:comment "A person known by this person (indicating some level of reciprocated interaction between the parties)."@en.

rdfs:comment rdfs:label "comment"@en;
             rdfs:comment "A description of the subject resource."

`rdfs:seeAlso` is a property to express
some link between two resources.

The meaning of this property is rather vague.
- Essentially, all regular Web links have type rdfs:seeAlso.

# rdf, rdfs, and foaf prefixes omitted for brevity
foaf:givenName rdfs:seeAlso foaf:familyName.

`rdf:type` is a property stating that
a resource is an instance of a class.

Resources can (and do) have multiple classes.
- Just because a class is not mentioned in a context
  does not mean a resource isn’t an instance of it.

# rdf, rdfs, and foaf prefixes omitted for brevity
<#me> rdf:type foaf:Person.
rdf:type rdf:type rdf:Property.
# Turtle and TriG allow a in predicate position.
<#me> a foaf:Person.
rdf:type a rdf:Property.

`rdfs:Resource` is a class
of which everything is an instance.

“_:x a rdfs:Resource” holds for all _:x.

# rdf, rdfs, and foaf prefixes omitted for brevity
<#me> a rdfs:Resource.
foaf:Person a rdfs:Resource.
rdfs:Resource a rdfs:Resource.
rdf:type a rdfs:Resource.

# Even literals are resources (Turtle cannot express this).
# "Tim"@en a rdfs:Resource.

`rdfs:Class` is a class for resources
that conceptually define a set of things.

# rdf, rdfs, and foaf prefixes omitted for brevity
foaf:Person a rdfs:Class.
rdfs:Resource a rdfs:Class.
rdfs:Class a rdfs:Class.
# Classes can serve as objects of rdf:type triples.
<#me> a foaf:Person.

# The following triples are semantically incorrect.
# rdf:seeAlso a rdfs:Class.
# <#me> a rdfs:Class.

`rdf:Property` is a class for resources
that can be used as triple predicates.

# rdf, rdfs, and foaf prefixes omitted for brevity
foaf:knows a rdf:Property.
rdf:type a rdf:Property.
rdf:Property a rdfs:Class.
# Properties can serve as predicates of triples.
<#Tim> foaf:knows <#Ted>.

# The following triples are semantically incorrect.
# rdfs:Class a rdf:Property.
# rdf:Property a rdf:Property.

`rdfs:Literal` is a class for resources
that have a literal value.

# rdf, rdfs, and foaf prefixes omitted for brevity

# Unfortunately, we cannot express this in Turtle.
# "Tim"@en a rdfs:Literal.
# 5 a rdfs:Literal.
# 2.7 a rdfs:Literal.

# The following triples are semantically incorrect.
# foaf:Person a rdfs:Literal.
# rdfs:Literal a rdfs:Literal.

`rdfs:subClassOf` is a property stating
all members of a class belong to another.

# rdf, rdfs, and foaf prefixes omitted for brevity
<#ComputerScientist> a rdfs:Class.
foaf:Person a rdfs:Class.
rdfs:Resource a rdfs:Class.
rdfs:Class a rdfs:Class.

<#ComputerScientist> rdfs:subClassOf foaf:Person.
foaf:Person rdfs:subClassOf foaf:Agent.
foaf:Person rdfs:subClassOf rdfs:Resource.
rdfs:Class rdfs:subClassOf rdfs:Resource.

`rdfs:domain` is a property that states
the class of possible subjects of a property.

Properties can have multiple domain restrictions.
- Subjects need to satisfy all of them.

# rdf, rdfs, and foaf prefixes omitted for brevity
foaf:img rdfs:domain foaf:Person.
foaf:img rdfs:domain rdfs:Resource.
rdf:type rdfs:domain rdfs:Resource.

rdfs:domain rdfs:domain rdf:Property.

`rdfs:range` is a property that states
the class of possible objects of a property.

Properties can have multiple range restrictions.
- Objects need to satisfy all of them.

# rdf, rdfs, and foaf prefixes omitted for brevity
foaf:img rdfs:range foaf:Image.
foaf:img rdfs:range rdfs:Resource.
rdf:type rdfs:range rdfs:Class.
rdf:type rdfs:range rdfs:Resource.

rdfs:range rdfs:range rdfs:Class.

`rdfs:subPropertyOf` is a property stating
a property is more specific than another.

If the subproperty holds for a subject and object,
the less specific property also holds.

# rdf, rdfs, and foaf prefixes omitted for brevity
<#hasFriend> rdfs:subPropertyOf foaf:knows.
rdfs:range rdfs:subPropertyOf rdfs:seeAlso.
rdfs:domain rdfs:subPropertyOf rdfs:seeAlso.

Knowledge of RDFS will help you
understand most vocabularies.

In particular, read the following vocabularies:

The Web Ontology Language (OWL) provides concepts for detailed ontologies.

RDFS captures basic ontological relations,
but lacks several common and important concepts.
- cardinality restrictions on properties
- inverse, symmetric, and transitive properties
- equality and disjointness
- …
OWL extends RDFS with advanced concepts.
- RDFS and OWL are used side by side.

OWL defines additional constraints
for individuals, properties, and classes.

restrictions on individuals
- owl:sameAs
- owl:differentFrom
- …
restrictions on properties
restrictions on classes
- owl:intersectionOf
- owl:Restriction
- …

OWL defines its own version
of resources and classes.

The class of everything is owl:Thing.
- similar to rdfs:Resource
The class of classes is owl:Class.
- subclass of rdfs:Class

An IRI uniquely identifies a resource,
but one resource can have many IRIs.

You cannot assume just because 2 IRIs are different
they necessarily point to different resources.
- ex:Tom a ex:Cat.
- ex:Jerry a ex:Mouse.
- You cannot conclude ex:Tom and ex:Jerry are different.
owl:sameAs indicates two resources are the same.
owl:differentFrom indicates two resources differ.
- ex:Tom owl:differentFrom ex:Jerry.

Typical properties can either take
a literal or a named node as object.

Properties taking only literal values as object
are instances of owl:DataTypeProperty.
- foaf:givenName a owl:DataTypeProperty.
- foaf:givenName rdfs:range rdfs:Literal.
Properties taking only non-literal values as object
are instances of owl:ObjectProperty.
- foaf:knows a owl:ObjectProperty.
- foaf:knows rdfs:range _:NonLiterals.
- _:NonLiterals owl:complementOf rdfs:Literal.

Inverse properties express a triple
in the opposite direction.

One property is the owl:inverseOf another
if it asserts the same relation from object to subject.
- ex:TimBL foaf:made dbr:World_Wide_Web.
- dbr:World_Wide_Web foaf:maker ex:TimBL.
- foaf:made owl:inverseOf foaf:maker.
Ontologists typically pick one property direction.
- Different ontologies might choose different directions.
- owl:inverseOf allows connecting such properties.

A functional property restricts the objects
for a given subject to be identical.

If any subject can at most have one unique value
for some property, it’s an owl:FunctionalProperty.
- ex:Julia ex:hasSpouse ex:Cathy.
- ex:hasSpouse a owl:FunctionalProperty.
The inverse is owl:InverseFunctionalProperty.
- ex:Elisabeth ex:successorOf ex:Philippe.
- ex:successorOf a owl:InverseFunctionalProperty.

OWL contains similar properties for
symmetry, reflexivity, and transitivity.

owl:SymmetricProperty
- ex:hasSpouse a owl:SymmetricProperty.
- opposite: owl:AsymmetricProperty
owl:ReflexiveProperty
- opposite: owl:IrreflexiveProperty
- ex:isMotherOf a owl:IrreflexiveProperty.
owl:TransitiveProperty
- owl:isFamilyMemberOf a owl:TransitiveProperty.

OWL allows defining classes
based on (properties of) other classes.

Make intersections and complements of classes
combined with restrictions on property value.

ex:Single owl:equivalentClass [ a owl:Class;
    owl:intersectionOf (foaf:Person, [
        a owl:Class, owl:Restriction;
        owl:onProperty ex:hasPartner;
        owl:maxCardinality 0
    ])
].

SPARQL Protocol And RDF Query Language: enable querying & updating RDF datasets.

SPARQL is a query language.
- Select specific data from an RDF dataset.
- Insert, change, or delete data in an RDF dataset.
The SPARQL protocol is a Web API definition
for querying in the SPARQL language over HTTP.
- A SPARQL endpoint executes SPARQL queries sent by clients
  through HTTP, and replies with their results.

The SPARQL language defines
forms a query can take.

There are currently 4 read-only query forms:

SELECT: find values that satisfy conditions
CONSTRUCT: create triples that satisfy conditions
ASK: check whether data exists
DESCRIBE: show information about a resource

The main building block of a SPARQL query
is a Basic Graph Pattern (BGP).

A BGP is a set of triple patterns.
- Their syntax is a superset of Turtle.
A triple pattern is a triple in which
each of the components can be a variable.
- Variables start with a question mark (?name).
A SPARQL query engine finds solution mappings.
- Variables and blank nodes are mapped to IRIs,
  blank nodes, or literals according to dataset triples.

This query finds artists
influenced by Picasso.

PREFIX dbr: <http://dbpedia.org/resource/>
PREFIX dbo: <http://dbpedia.org/ontology/>
SELECT ?name ?person WHERE {
  ?person a dbo:Artist.
  ?person foaf:name ?name.
  ?person dbo:influencedBy dbr:Pablo_Picasso.
}

A query engine will try to find mappings
such that the entire BGP is satisfied.

When the mappings are substituted in the BGP,
the dataset should contain triples as follows:

?person a dbo:Artist.
?person foaf:name ?name.
?person dbo:influencedBy dbr:Pablo_Picasso.

Evaluating this query against DBpedia
returns possible mappings.

A `CONSTRUCT` query
returns matching triples.

An `ASK` query returns a boolean stating
whether the pattern exists in the dataset.

A `DESCRIBE` query returns (non-specified)
contextual information for resources.

In addition to only BGPs,
SPARQL queries can contain modifiers.

LIMIT: only return the first n results
OPTIONAL: specifies a left join
FILTER: selects based on an expression
ORDER BY: sorts results based on an expression
…: …

In addition to only BGPs,
SPARQL queries can contain modifiers.

The purpose of the SPARQL protocol
is sending queries and receiving results.

The server is typically an RDF database (triplestore)
with a SPARQL query engine.
The client sends a query using a URI template.
- In essence, /sparql?query={query} with
  a URL-encoded SPARQL query through GET or POST.
The server replies in a standardized format.
- XML
- JSON
- CSV/TSV
- RDF (for CONSTRUCT/DESCRIBE)

Semantic Web reasoning is an agent’s
ability to verify and discover facts.

Linked Data provides a body of knowledge.
- data triples
- ontologies
Query engines let clients select specific facts.
Reasoning allows clients to combine knowledge
from different sources and draw conclusions.
- Clients infer facts based on other facts.

Some reasoners are tailored to a task,
others can/need to be extended.

reasoner with built-in knowledge
- can tackle a problem without configuration
- can have internal optimizations for certain cases
reasoner without built-in knowledge
- can be extended with new inference steps
- can explain in-depth why a step was taken

Rule-based reasoners allow you
to choose and define your own rules.

The internal knowledge is limited to rule evaluation
and sometimes built-in functions (math, dates, …).
- All reasoning steps are explicit.
Several rule languages and syntaxes exist.
- Notation3
- RIF
- …
Rules that implement specific ontological concepts
are often available and reusable.
- Some (such as disjunction) might not be implementable.

Notation3 (N3) is a rule-based language
defined as a superset of Turtle.

N3 adds support for additional constructs.

variables

?name

formulas

{ ?x a foaf:Person. }

implications

{ … } => { … }.
Several N3 reasoners exist.
- cwm
- EYE
- …
Common RDFS and OWL concepts exist as N3 rules.
- Read them when in doubt about RDFS or OWL concepts.

We can define rules
for very specific situations.

Defining rules at a higher level
increases their reusability.

Defining rules at the ontological level
makes a vocabulary declarative.

I don’t need to fight
to prove I’m right.

I don’t need to be forgiven.
The Who – Baba O'Riley

The Semantic Web is a layer on top of the existing Web.

The Semantic Web layer is integrated into the existing Web.

Tim Berners-Lee proposed 4 principles to publish Linked Data.

The Linked Data principles resemble the REST uniform interface constraints.

Information & non-information resources should be uniquely identifiable.

Using HTTP URIs ensures that anybody can look up the resource.

Dereferencing a URI should lead to useful information about that resource.

By including links to other resources, we create a Web of Data.

The basic information unit in Linked Data is a link from one resource to another.

Those two resources each are identified by an HTTP URI.

To simplify their display, we abbreviate URIs using prefixes.

In contrast to typical Web links, these links are typed with a URI we can dereference.

This means that a link type (property) is also a resource we can describe.

In addition to resources, link targets can also be literal values.

By linking resources together this way, we create a Web of Linked Data.

Prefixes are a convention, so they can be chosen freely.

An immense amount of Linked Data is available on the Web for reuse.

No Linked Data set is ever complete. We make the open-world assumption.

Several vocabularies are used frequently across different datasets.

The Dublin Core terms are a set of 15 common metadata properties.

Schema.org is a single vocabulary that covers many different fields.

Billions of Linked Data facts are published on the Web with an open license.

The Resource Description Framework is a model for data interchange on the Web.

This Linked Data fact can be represented as an RDF triple.

This Linked Data fact can be represented as an RDF triple.

There are 3 types of RDF terms: named nodes, blank nodes, and literals.

This RDF triple has a literal as an object.

This RDF triple has a literal as an object.

This RDF triple has a literal as an object.

This is an RDF graph consisting of a set of triples.

An RDF dataset has one default graph and zero or more named graphs.

Several standard syntaxes for RDF exist. Some of them have multi-graph support.

N-Triples is a line-based syntax supporting only a default graph.

Turtle is a superset of N-Triples with prefixes and abbreviations.

Turtle includes syntactic sugar to write blank nodes.

Turtle includes syntactic sugar to write (head/tail) lists.

N-Quads is a superset of N-Triples with support for named graphs.

TriG is a superset of Turtle (not N-Quads) with support for named graphs.

JSON-LD is a JSON syntax to represent an RDF dataset, supporting named graphs.

JSON-LD provides additional interpretation on top of the JSON specification.

JSON-LD documents look almost like regular JSON documents.

JSON-LD documents can be approached like regular JSON documents.

JSON-LD documents can be approached as RDF triples (or quads).

The XML-based syntax for RDF represents triples, but not named graphs.

Choose the right RDF syntax based on graph support and client technology.

RDFa allows extending generic HTML and XML documents with RDF triples.

This RDFa example interleaves HTML markup with RDF triples.

The extracted RDFa data is regular RDF that can be converted to other formats.

RDF on the Web can be found in webpages and through content negotiation.

RDF Schema is an RDF vocabulary to model RDF vocabularies.

Practitioners in the RDF world often refer to vocabularies as ontologies.

RDFS defines the basic building blocks to construct RDF vocabularies.

rdfs:label is a property that gives a human-readable name to a resource.

rdfs:comment is a property that clarifies human-readable meaning and usage.

rdfs:seeAlso is a property to express some link between two resources.

rdf:type is a property stating that a resource is an instance of a class.

rdfs:Resource is a class of which everything is an instance.

rdfs:Class is a class for resources that conceptually define a set of things.

rdf:Property is a class for resources that can be used as triple predicates.

rdfs:Literal is a class for resources that have a literal value.

rdfs:subClassOf is a property stating all members of a class belong to another.

rdfs:domain is a property that states the class of possible subjects of a property.

rdfs:range is a property that states the class of possible objects of a property.

rdfs:subPropertyOf is a property stating a property is more specific than another.

Knowledge of RDFS will help you understand most vocabularies.

The Web Ontology Language (OWL) provides concepts for detailed ontologies.

OWL defines additional constraints for individuals, properties, and classes.

OWL defines its own version of resources and classes.

An IRI uniquely identifies a resource, but one resource can have many IRIs.

Typical properties can either take a literal or a named node as object.

Inverse properties express a triple in the opposite direction.

A functional property restricts the objects for a given subject to be identical.

Functional properties have strong effects, so you have to understand them well.

OWL contains similar properties for symmetry, reflexivity, and transitivity.

OWL allows defining classes based on (properties of) other classes.

SPARQL Protocol And RDF Query Language: enable querying & updating RDF datasets.

The SPARQL language defines forms a query can take.

The main building block of a SPARQL query is a Basic Graph Pattern (BGP).

This query finds artists influenced by Picasso.

A query engine will try to find mappings such that the entire BGP is satisfied.

The Semantic Web is a layer
on top of the existing Web.

The Semantic Web layer is integrated
into the existing Web.

Tim Berners-Lee proposed
4 principles to publish Linked Data.

The Linked Data principles resemble
the REST uniform interface constraints.

Information & non-information resources
should be uniquely identifiable.

Using HTTP URIs ensures that
anybody can look up the resource.

Dereferencing a URI should lead to
useful information about that resource.

By including links to other resources,
we create a Web of Data.

The basic information unit in Linked Data
is a link from one resource to another.

Those two resources each
are identified by an HTTP URI.

To simplify their display,
we abbreviate URIs using prefixes.

In contrast to typical Web links, these links
are typed with a URI we can dereference.

This means that a link type (property)
is also a resource we can describe.

In addition to resources,
link targets can also be literal values.

By linking resources together this way,
we create a Web of Linked Data.

Prefixes are a convention,
so they can be chosen freely.

An immense amount of Linked Data
is available on the Web for reuse.

No Linked Data set is ever complete.
We make the open-world assumption.

Several vocabularies are used frequently
across different datasets.

The Dublin Core terms are a set of
15 common metadata properties.

Schema.org is a single vocabulary
that covers many different fields.

Billions of Linked Data facts are published
on the Web with an open license.

The Resource Description Framework is
a model for data interchange on the Web.

This Linked Data fact can be
represented as an RDF triple.

This Linked Data fact can be
represented as an RDF triple.

There are 3 types of RDF terms:
named nodes, blank nodes, and literals.

This RDF triple has
a literal as an object.

This RDF triple has
a literal as an object.

This RDF triple has
a literal as an object.

This is an RDF graph
consisting of a set of triples.

An RDF dataset has one default graph
and zero or more named graphs.

Several standard syntaxes for RDF exist.
Some of them have multi-graph support.

N-Triples is a line-based syntax
supporting only a default graph.

Turtle is a superset of N-Triples
with prefixes and abbreviations.

Turtle includes syntactic sugar
to write blank nodes.

Turtle includes syntactic sugar
to write (head/tail) lists.

N-Quads is a superset of N-Triples
with support for named graphs.

TriG is a superset of Turtle (not N-Quads)
with support for named graphs.

JSON-LD is a JSON syntax to represent
an RDF dataset, supporting named graphs.

JSON-LD provides additional interpretation
on top of the JSON specification.

JSON-LD documents look almost
like regular JSON documents.

JSON-LD documents can be approached
like regular JSON documents.

JSON-LD documents can be approached
as RDF triples (or quads).

The XML-based syntax for RDF
represents triples, but not named graphs.

Choose the right RDF syntax based on
graph support and client technology.

RDFa allows extending generic HTML
and XML documents with RDF triples.

This RDFa example interleaves
HTML markup with RDF triples.

The extracted RDFa data is regular RDF
that can be converted to other formats.

RDF on the Web can be found in webpages
and through content negotiation.

RDF Schema is an RDF vocabulary
to model RDF vocabularies.

Practitioners in the RDF world often
refer to vocabularies as ontologies.

RDFS defines the basic building blocks
to construct RDF vocabularies.

`rdfs:label` is a property that gives
a human-readable name to a resource.

`rdfs:comment` is a property that clarifies
human-readable meaning and usage.

`rdfs:seeAlso` is a property to express
some link between two resources.

`rdf:type` is a property stating that
a resource is an instance of a class.

`rdfs:Resource` is a class
of which everything is an instance.

`rdfs:Class` is a class for resources
that conceptually define a set of things.

`rdf:Property` is a class for resources
that can be used as triple predicates.

`rdfs:Literal` is a class for resources
that have a literal value.

`rdfs:subClassOf` is a property stating
all members of a class belong to another.

`rdfs:domain` is a property that states
the class of possible subjects of a property.

`rdfs:range` is a property that states
the class of possible objects of a property.

`rdfs:subPropertyOf` is a property stating
a property is more specific than another.

Knowledge of RDFS will help you
understand most vocabularies.

OWL defines additional constraints
for individuals, properties, and classes.

OWL defines its own version
of resources and classes.

An IRI uniquely identifies a resource,
but one resource can have many IRIs.

Typical properties can either take
a literal or a named node as object.

Inverse properties express a triple
in the opposite direction.

A functional property restricts the objects
for a given subject to be identical.

Functional properties have strong effects,
so you have to understand them well.

OWL contains similar properties for
symmetry, reflexivity, and transitivity.

OWL allows defining classes
based on (properties of) other classes.

The SPARQL language defines
forms a query can take.

The main building block of a SPARQL query
is a Basic Graph Pattern (BGP).

This query finds artists
influenced by Picasso.

A query engine will try to find mappings
such that the entire BGP is satisfied.

Evaluating this query against DBpedia
returns possible mappings.

A `CONSTRUCT` query
returns matching triples.