RDF (Resource Description Framework)

An RDF triple is the fundamental, atomic data unit, forming a single statement or fact. It consists of three components:

• Subject: The resource being described (a URI or blank node).
• Predicate: The property or relationship (always a URI).
• Object: The value of the property (a URI, literal, or blank node).

This structure creates a machine-readable assertion, such as (ex:ProductX, ex:manufacturedBy, ex:CompanyY). Billions of interconnected triples form a global knowledge graph.

URIs provide global, unambiguous names for resources, ensuring entities and relationships are uniquely identifiable across systems. They are the backbone of Linked Data.

• Subjects and Predicates are almost always identified by URIs (e.g., http://schema.org/Person).
• This allows decentralized data from different sources to be seamlessly connected by referencing the same URI.
• Unlike database primary keys, URIs are web-accessible, enabling both identification and potential dereferencing to obtain more information.

Literals are values used as the object in a triple to represent raw data like strings, numbers, or dates. They are not resources themselves but concrete values.

• A plain literal is a simple string: "Inferensys".
• A typed literal includes an explicit datatype URI (e.g., "42"^^xsd:integer, "2024-05-15"^^xsd:date).
• An optional language tag can be attached to string literals for internationalization: "Hello"@en, "Bonjour"@fr. This precision is critical for data validation, sorting, and mathematical operations.

A blank node (or bnode) is an anonymous resource used as a subject or object when a distinct URI is unnecessary or unknown. It represents an existential variable—"a thing that exists."

• Used for complex values: describing an address without needing to give the address itself a global URI.
• Used for intermediate structures: ex:Report ex:authoredBy [ a ex:Person; ex:name "Jane Doe" ].
• Their scope is typically limited to the specific RDF document or dataset. They are locally unique identifiers, not globally dereferenceable.

The collection of all triples forms a directed, labeled graph.

• Nodes: Subjects and objects (URIs, blank nodes, literals).
• Directed Edges: Predicates (URIs), linking subjects to objects.
• This graph-based model is inherently flexible, allowing new types of relationships and entities to be added without schema alteration.
• The graph can be queried by traversing these edges, enabling powerful pattern-matching operations that are difficult in relational databases.

An abstract RDF graph must be serialized into a concrete syntax for exchange. Common formats include:

• Turtle (TTL): A compact, human-readable text format using prefixes. The preferred choice for authoring and documentation.
• RDF/XML: The original XML-based syntax, standardized by the W3C.
• JSON-LD: Serializes RDF as JSON, ideal for web APIs and JavaScript integration.
• N-Triples: A very simple line-based format with one triple per line; easy to parse.
• RDFa: Embeds RDF within HTML attributes for semantic markup of web pages. Each format represents the same underlying graph model.

Turtle is the predominant human-readable text format for authoring and exchanging RDF. It uses a compact syntax with prefixes to abbreviate URIs, supports shorthand for lists and nested blank nodes, and is the recommended format for most RDF work.

• Key Feature: Uses @prefix declarations (e.g., @prefix ex: <http://example.org/>) to enable concise ex:subject ex:predicate ex:object . triples.
• Example: ex:Alice ex:knows ex:Bob ; ex:age 30 .
• Primary Use: Manual editing, documentation, and clear data dumps.

JSON-LD serializes RDF as JSON, making it the ideal format for integrating semantic data into modern web APIs and JavaScript applications. It uses a @context to map JSON keys to global URIs, allowing the same data to be processed as plain JSON or as a full RDF graph.

• Key Feature: The @context provides semantic meaning to JSON structures, enabling round-tripping between linked data and application-specific JSON.
• Example: {"@context":{"name":"http://xmlns.com/foaf/0.1/name"}, "@id":"http://me.example.com", "name":"Alice"}
• Primary Use: Web APIs, microservices, and applications where JSON is the native data format.

RDF/XML is the original, canonical XML-based serialization defined in the 2004 RDF specification. It represents the RDF graph as an XML document, which can be validated and processed by standard XML tools.

• Key Feature: Official W3C standard format; any compliant RDF processor must be able to read and write RDF/XML.
• Drawback: The XML syntax can be verbose and complex for representing graph structures, making it less human-friendly than Turtle.
• Primary Use: Legacy systems, environments with mandated XML interchange, and formal W3C specifications.

N-Triples is a simple, line-based format where each line contains exactly one triple in fully expanded form (no prefixes). N-Quads extends N-Triples by adding an optional fourth field for a graph name, aligning with the RDF Dataset concept.

• Key Feature: Simplicity and predictability. The lack of abbreviations makes it ideal for stream processing, automated parsing, and large-scale data dumps where consistency is critical.
• Example (N-Triples): <http://example.org/Alice> <http://xmlns.com/foaf/0.1/name> "Alice" .
• Example (N-Quads): ... "Alice" <http://example.org/graph1> .
• Primary Use: Large dataset exchange, stream processing, and intermediate format for RDF parsers.

RDFa is a markup language for embedding RDF data directly into HTML, XHTML, and XML documents using attributes. It allows publishers to add machine-readable metadata to human-readable web pages without duplicating content.

• Key Feature: Co-locates data and presentation. Uses HTML attributes like property, resource, and typeof to annotate existing page elements.
• Example: <div resource="http://example.org/Alice" typeof="foaf:Person"> <span property="foaf:name">Alice</span> </div>
• Primary Use: Search engine optimization (SEO) via schema.org, publishing linked data on the web, and enabling rich snippets.

TriG is a format that extends Turtle to serialize an entire RDF Dataset (a collection of named graphs and a default graph). TriX (Triples in XML) is an XML-based format for serializing RDF datasets.

• Key Feature (TriG): Uses Turtle syntax with the addition of graph labels wrapped in curly braces { } to group triples. Provides a compact, readable way to exchange multi-graph data.
• Example (TriG): ex:defaultTriple . GRAPH ex:Graph1 { ex:Alice ex:knows ex:Bob . }
• Primary Use: Exchanging datasets with provenance, context, or access control information stored in named graphs.

RDFS (RDF Schema) is a semantic extension of RDF that provides a basic vocabulary for defining taxonomies and ontologies. It introduces fundamental constructs like:

• rdfs:Class and rdfs:subClassOf for class hierarchies.
• rdfs:Property, rdfs:domain, and rdfs:range for defining and constraining properties.
• rdfs:label and rdfs:comment for human-readable documentation. RDFS enables simple inference, such as automatically classifying an instance of a subclass as also being an instance of its superclass. It is the first step beyond plain RDF triples toward a formal knowledge representation.

OWL (Web Ontology Language) is a family of knowledge representation languages built on top of RDF/RDFS, with formal semantics based on Description Logics. It is used to define rich, complex ontologies that support advanced automated reasoning. Key capabilities include:

• Defining complex class relationships (union, intersection, complement).
• Specifying property characteristics (transitive, symmetric, functional).
• Defining equivalence between classes or individuals.
• Enforcing cardinality restrictions (e.g., a Person has exactly one biological mother). OWL comes in profiles (OWL 2 EL, QL, RL) that trade expressive power for computational efficiency, making it suitable for large-scale knowledge graphs and enterprise reasoning tasks.

SPARQL is the standard query language and protocol for RDF data. It enables complex graph pattern matching, similar to SQL for relational databases but designed for interconnected graph data. Core query forms include:

• SELECT: Returns a table of matched variables.
• CONSTRUCT: Creates a new RDF graph from query results.
• ASK: Returns a boolean indicating if a pattern matches.
• DESCRIBE: Returns an RDF graph describing a resource. SPARQL supports property paths for concise path traversal, federated queries across distributed endpoints, and SPARQL Update for modifying graphs. It is executed via a SPARQL endpoint, an HTTP service that provides programmatic access to a triplestore.

A triplestore is a purpose-built database system optimized for the storage, retrieval, and management of RDF triples. Unlike relational databases, triplestores are designed for the schema-later nature of graph data and efficient execution of graph pattern matching queries (SPARQL). Key features include:

• Native indexing on subject, predicate, and object for fast triple lookups.
• Support for inference engines that materialize entailed triples using RDFS or OWL semantics.
• Management of named graphs for grouping triples into contextual sub-graphs.
• Horizontal scalability for large knowledge graphs. Examples include Stardog, GraphDB, and Apache Jena Fuseki. They form the core infrastructure for enterprise knowledge graphs.

Linked Data is a set of best practices for publishing and interconnecting structured data on the web using RDF. It is the methodological framework that realizes the Semantic Web vision. The four core principles, as defined by Tim Berners-Lee, are:

1. Use URIs as names for things.
2. Use HTTP URIs so people can look up those names.
3. When someone looks up a URI, provide useful information using standards (RDF, SPARQL).
4. Include links to other URIs to discover more related things. This creates a Web of Data where datasets from different sources are explicitly connected, enabling federated querying and integration. Enterprise knowledge graphs often adopt Linked Data principles for internal data unification.

JSON-LD (JSON for Linked Data) is a lightweight RDF serialization format that expresses linked data using JSON. It is designed for easy integration of semantic data into modern web applications and RESTful APIs. Key features include:

• A @context object that maps JSON keys to URIs in an ontology, providing semantic meaning.
• The ability to serialize a full RDF graph in a way that is both machine-processable and intuitive for developers familiar with JSON.
• Framing capabilities to shape the JSON output into a specific tree structure. JSON-LD enables websites to embed structured data for search engine understanding (Schema.org) and allows microservices to exchange semantically precise data without requiring a separate triplestore endpoint.