RDF Triple

The subject is the first component of an RDF triple and represents the resource or entity about which a statement is made. It is always a URI (Uniform Resource Identifier) or a blank node. The subject is the starting point of the graph edge.

• URI Subjects: Provide a globally unique, dereferenceable identifier (e.g., http://example.org/person/Alice).
• Blank Node Subjects: Represent an anonymous resource or a "something" that exists but doesn't need a global name (e.g., _:bnode1).
• In a graph visualization, the subject is always the source node from which the relationship arrow originates.

The predicate is the second component and defines the type of relationship or property that links the subject to the object. It is always a URI, which ensures the relationship's meaning is unambiguous and defined in a shared vocabulary or ontology.

• Core Function: Acts as the labeled edge or arc in the graph.
• Standard Vocabularies: Predicates often come from well-known schemas like Dublin Core (dc:creator), FOAF (foaf:knows), or Schema.org (schema:worksFor).
• Custom Properties: Organizations define their own predicate URIs within their namespace to model domain-specific relationships (e.g., https://mycorp.com/ontology#manufacturedIn).

The object is the third component and is the value of the property for the given subject. It can be one of two types:

• URI Object: Another named resource, creating a link between two nodes in the graph (e.g., http://example.org/city/London). This forms a relationship triple.
• Literal Object: A raw data value, such as a string, number, or date (e.g., "Alice", 42, "2023-10-27"^^xsd:date). This forms an attribute triple. Literals can have an optional datatype URI (e.g., xsd:integer) or a language tag (e.g., "Bonjour"@fr).

In the graph, a URI object is a target node, while a literal object is typically displayed as text attached to the subject node.

When combined, the three components form a complete, machine-readable statement of fact. The structure (Subject, Predicate, Object) is analogous to the grammatical structure of a simple sentence: (Alice, worksFor, AcmeCorp) or (Alice, hasAge, "30"^^xsd:integer).

• Atomicity: The triple is the smallest unit of meaning in RDF; you cannot have a valid statement with fewer than three components.
• Mergeability: Triples from different sources can be merged into a single graph if they share URIs, enabling data integration.
• Example: The triple <http://example.org/Book1> <http://purl.org/dc/terms/title> "Semantic Web Primer" . states a definitive fact that can be combined with other facts about Book1.

RDF triples can be written (serialized) in multiple concrete syntaxes while preserving the same logical model. Common formats include:

• Turtle (.ttl): A compact, human-readable format using prefixes and shorthand. Example: ex:Book1 dc:title "Semantic Web Primer" .
• N-Triples (.nt): A simple, line-based format where every triple is fully written. One triple per line. Example: <http://example.org/Book1> <http://purl.org/dc/terms/title> "Semantic Web Primer" .
• RDF/XML: An XML-based syntax, historically important but less readable.
• JSON-LD: Serializes RDF as JSON, ideal for web APIs.

Despite different syntaxes, the underlying triple structure of subject, predicate, and object remains constant.

A collection of interconnected RDF triples forms a directed, labeled graph—the core of a knowledge graph. The power comes from linking subjects and objects via shared URIs.

• Graph Formation: If the object of one triple is the subject of another, they connect, creating a path. For example: (ex:Alice, ex:worksFor, ex:AcmeCorp) and (ex:AcmeCorp, ex:locatedIn, ex:London).
• Inference: New triples can be inferred from existing ones using rules (e.g., RDFS or OWL semantics). If a rule states worksFor is a subproperty of associatedWith, a reasoner can infer (ex:Alice, ex:associatedWith, ex:AcmeCorp).
• Querying: The SPARQL query language is designed to match patterns across these interconnected triples, enabling powerful graph traversal queries.

Turtle is the predominant human-readable syntax for authoring RDF. It uses prefix declarations (like @prefix) to abbreviate URIs and supports shorthand for lists and nested blank nodes.

Example:

turtleCopy
@prefix ex: <http://example.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

ex:alice ex:hasAge "30"^^xsd:integer .
ex:alice ex:knows ex:bob .

• The @prefix lines define shortcuts for long URIs.
• The ^^ notation specifies a datatype for a literal.
• A triple ends with a period.

N-Triples is a simple, line-based format where each triple is fully specified on a single line using absolute URIs. It is often used for dataset exchange and processing due to its lack of ambiguity.

Example:

ntriplesCopy
<http://example.org/alice> <http://example.org/name> "Alice" .
<http://example.org/alice> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .

• Every URI is written in full, enclosed in angle brackets <...>.
• Literals are enclosed in double quotes.
• Each line contains exactly one triple and ends with a period and a newline.

RDF/XML is the original W3C-standardized XML syntax for RDF. It represents triples as nested XML elements, which can be verbose but is processable by standard XML tools.

Example:

xmlCopy
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:ex="http://example.org/">
  <rdf:Description rdf:about="http://example.org/book1">
    <ex:title>Semantic Web Primer</ex:title>
    <ex:author rdf:resource="http://example.org/author1"/>
  </rdf:Description>
</rdf:RDF>

• The rdf:Description element represents the subject.
• Child elements like ex:title represent predicates, with their content or rdf:resource attribute as the object.
• Namespace declarations (xmlns:...) define prefixes.

JSON-LD serializes RDF as JSON, making it easily consumable by web applications. It uses a context (@context) to map JSON terms to IRIs and defines the graph structure.

Example:

jsonCopy
{
  "@context": {
    "ex": "http://example.org/",
    "name": "ex:name",
    "knows": {"@id": "ex:knows", "@type": "@id"}
  },
  "@id": "ex:alice",
  "name": "Alice",
  "knows": {
    "@id": "ex:bob",
    "name": "Bob"
  }
}

• The @context compacts IRIs to simple keys like "name".
• The @id keyword denotes a subject or object resource.
• The "@type": "@id" hint in the context indicates "knows" expects a resource object, not a literal.

SPARQL queries return triples or bindings that represent matched graph patterns. The SELECT form returns variable bindings, while CONSTRUCT returns new RDF triples.

Example SELECT Results (JSON):

jsonCopy
{
  "head": {"vars": ["person", "age"]},
  "results": {
    "bindings": [
      {
        "person": {"type": "uri", "value": "http://example.org/alice"},
        "age": {"type": "literal", "datatype": "http://www.w3.org/2001/XMLSchema#integer", "value": "30"}
      }
    ]
  }
}

Example CONSTRUCT Output (Turtle): A CONSTRUCT { ?s ex:isAdult true . } WHERE { ?s ex:age ?age . FILTER(?age >= 18) } query would generate new triples like ex:alice ex:isAdult true .

RDF-star extends RDF syntax to allow triples themselves to be the subject or object of another triple, enabling native representation of provenance, confidence, or temporal context.

Example in Turtle-star:

turtleCopy
@prefix ex: <http://example.org/> .
@prefix prov: <http://www.w3.org/ns/prov#> .

<< ex:alice ex:reported ex:incident123 >> prov:generatedAtTime "2024-01-15T10:30:00Z"^^xsd:dateTime .
<< ex:alice ex:reported ex:incident123 >> prov:wasDerivedFrom <http://internal.log/alert445> .

• The << ... >> syntax embeds a triple, making it a node that can be described.
• This allows attaching metadata (like source and timestamp) directly to a factual assertion without redesigning the ontology.