N3 document

An N3 document represents an N3 graph in a compact textual form. An N3 graph is a series of N3 statements. These are written as triples consisting of a subject, predicate, and object resource. An N3 resource can be an RDF IRI, literal or blank node; or an N3 graph term, collection, logical implication, variable or N3 builtin. We introduce these types of resources and statements below.

Comments are indicated using a separate '#' and continue until the end of the line.

Simple triples

The simplest N3 statement or triple is a sequence of a subject, predicate, and object resource, separated by whitespace and terminated by '`.`' after each triple.

In the example below, three N3 triples highlight the enmity between Spiderman and the Green Goblin and lists their human-readable names:

There is no inherent order for N3 or RDF triples. The same is true for the relational database model, i.e., relational tuples or rows do not have an inherent order. Hence, it is a mistake to associate meaning with the order of statements in an N3 document (e.g., assuming that a first listed telephone for Spiderman is their landline, and the second one their mobile number).

Predicate and object lists

As shown in the above example, the same subject (here, Spiderman) will often be described by several N3 statements. To make these N3 statements less cumbersome to write, one can put a semicolon (";") at the end of an N3 statement to describe the same subject in the subsequent statement:

Similarly, a predicate (e.g., name) can often list multiple objects for the same subject (e.g., Spiderman). This can be written by listing the object values separated by a ',':

IRIs

An IRI is used to represent an identifiable entity — such as a person, place, or thing. Until now, we have been writing absolute IRIs [[RFC3987]] (e.g., https://example.org/Spiderman), which include both the namespace (e.g., https://example.org/) and the local name (e.g., Spiderman).

It is often much easier to write an IRI as a prefixed name — e.g., ex:Spiderman, which includes a prefix label (e.g., ex) as a shorthand for the namespace, and the local name (e.g., Spiderman), separated by a colon (":"). The `@prefix` directives associate the prefix label with a namespace IRI. A prefixed name is turned into an absolute IRI by concatenating the namespace IRI with the local name. The following example is equivalent to the original example:

N3 also supports case-insensitive `PREFIX` and `BASE` directives, as does Turtle, to align the syntax with SPARQL (see grammar). These do not have a trailing '.'.

To further simplify prefixed names, one can leave the prefix label empty (e.g., for an often-used namespace):

One can also write relative IRI references, e.g., <#Spiderman>. A relative IRI reference is resolved, i.e., turned into an absolute IRI, by concatenating the base IRI with the local name (e.g., Spiderman). A base IRI is defined using the `@base` directive. For instance, the following is equivalent to the prior example:

Specifics of relative IRI reference resolution are described in .

We recommend listing `@prefix` / `PREFIX` and `@base` / `BASE` declarations at the top of an N3 document. This is not mandatory, however, and they can technically be put anywhere before the prefixed name or relative IRI that relies on the declaration. Subsequent `@prefix` / `PREFIX` directives may "re-map" the same prefix label to another namespace IRI.

Literals

Literals are used to represent a textual or numerical (i.e., datatype) value, such as name, date, height, and so on. Numbers (integers, decimals, and doubles) are simply represented using their numerical value, and booleans are represented using true or false:

For details on numerical syntaxes (e.g., decimals, doubles), we refer to the RDF 1.1: Turtle (Section 2.5.2) specification.

Other literals, such as strings, but also dates, binary, octal or hex code, XML or JSON code, or other types of numbers (e.g., shorts), need to be written as datatyped literals. These are represented as a string, followed by the `^^` symbol and the corresponding datatype IRI. (`xsd:string` is the datatype IRI for strings; this is the default and can be omitted, in which case the `^^` MUST also be omitted; in other words, `"example"^^` is not a valid datatyped literal). For instance:

The language of the string literal can be indicated using the @ symbol and the corresponding language tag (as defined in [[BCP47]] — find the registry in [[LNG-TAG]]). For instance:

The reading direction can be described together with the language [[BCP47]], using the i18n namespace:

If no datatype IRI or language tag is given, the datatype xsd:string will be assumed. In case a language tag is given or a i18n "datatype" is used, the datatype rdf:langString is inferred. It is not possible to specify both a datatype IRI and a language tag.

There are also other ways to describe the language tag and base direction of RDF literals, see Compound literals. Please note that these various ways are still in flux, see the "text direction" discussions in the RDF-star working group.

Integers, decimals, doubles, and booleans may also be written as string literals with the appropriate datatype IRI (e.g., `"8"^^xsd:integer` or `"true"^^xsd:boolean`).

In case the the string literal itself contains the string delimiter (e.g., double quotes), or includes newlines, other string delimiters can be used, i.e., single quotes or compound delimiters "carview.php?tsp="carview.php?tsp=" or '''. Alternatively, one can also use a '\' for escaping the delimiter each time it occurs within a string literal. For instance:

The escape symbol '\' (U+005C) may only appear in a string literal as part of an escape sequence. Other restrictions within string literals depend on the delimiter:

• Literals delimited by ' may not contain the characters ', _LF (U+000A), or _CR (U+000D).
• Literals delimited by " may not contain the characters ", _LF, or _CR.
• Literals delimited by ''' may not contain the sequence of characters '''.
• Literals delimited by """ may not contain the sequence of characters """.

Blank Nodes

When describing resources in RDF, you can run into the following situations:

• It is not worth minting a new IRI for the resource, as it is unlikely that other N3 graphs will refer to it.
• There likely already exists an IRI for the resource, and we don't want to do an extensive search to find out what it is.

Instead, you can use blank nodes to talk about resources. They are existential variables; that is, they state the existence of a thing without identifying it. Blank nodes can be represented in several ways, as described below. For details, please refer to ([[[RDF11-CONCEPTS]]]).

Collections

We often need to describe ordered collections of things, e.g., a book written by several authors, listing the students in a course, or the software modules within a package. N3 supports collections as first-class citizens to represent ordered collections of resources enclosed by parentheses ("( )"). The contained resources are called members.

For instance:

This states that the value of the author property is the collection resource.

Any additional meaning is not given by the N3 semantics. For instance, this example does not imply that each member (e.g., :deborah) can be considered as a value of the author property — i.e., the author property does not "distribute" across the members. For that matter, it is also not implied that the first member put the most effort into the book. Any additional meaning, such as each member being an author of the book, and the ordering reflecting the authors' effort, would always be application-specific.

In general, to implement such application-specific meanings, N3 rules could be used. Alternatively, one could use an object list to explicitly state that each of these resources are authors of the book:
    `:description_logic_handbook :author :deborah, :daniele, :peter .`
However, since RDF (and thus N3) statements do not have an inherent order, this example loses meaning as we no longer know who can be considered the "first" author.

To an extent, an N3 collection is equivalent to the more verbose RDF Collection vocabulary. We refer to the original N3 submission for the additional axioms needed for this equivalency.

In N3, collections may occur as subjects, predicates or objects in a statement. For instance:

Or even:

As before: any meaning that goes beyond the fact that 3 collection resources are involved in this statement, would be application-specific.

Graph Terms

It is often useful to attach metadata to groups of triples — to give the provenance, context, or version of the information, our opinion on the matter, and so on. We can use graph terms to quote RDF graphs, and then describe the graph term using N3 statements. For instance:

Essentially, a graph term represents an occurrence of an RDF graph — i.e., a quoting or citing of the graph. Importantly, a graph term does not assert the contents of the RDF graph as being true (e.g., :cervantes dc:wrote :moby_dick). In fact, the graph term is interpreted as a resource on its own.

As with collections, graph terms can be used in any position in an N3 statement.

As they represent a quoting of RDF graphs, graph terms are not "referentially transparent". For instance:

This N3 statement states that Lois Lane believes that Superman can fly. Even if it is known that :Superman is the same as :ClarkKent, one cannot infer from this that Lois Lane believes that :ClarkKent can fly. Indeed, this is an accurate depiction of Lois Lane's statement at the time — as she did not know that Superman is Clark Kent at that point, she would certainly not be saying that Clark Kent can fly.

N3 Rules

N3 supports declarative programming by allowing to make statements about the world, including logical implications, or N3 rules, which can be loosely compared to If-Then statements. Based on the N3 semantics, so-called inferences can be drawn from these statements. An N3 reasoner can draw such inferences automatically, to support problem solving, decision making, or simply enriching your Knowledge Graph.

For instance, the following is an N3 rule:

This is a logical construct, such as a conjunction (AND) and disjunction (OR). Stating such a logical implication means that, in case the rule premise is true (it is raining), the rule conclusion must be true as well (it is cloudy). If this is not the case — raining does not imply that it is cloudy — the implication would be false. However, this is not possible, since all statements in N3 (and RDF) are true by default.

Hence, when the premise holds, then we can safely infer the conclusion. This is also referred to as firing the rule. For the example above, if we state `:weather a :Raining`, then we can safely infer `:weather a :Cloudy`.

An N3 rule is actually a N3 statement, where the subject and object constitute graph terms, and the predicate is `log:implies`, with symbol `=>` as syntactic sugar.

N3 Builtins

An N3 builtin is used within an N3 rule to implement an arbitrary operation on an N3 resource or even an entire N3 document. Builtins include mathematic, string, time and cryptography operators, operations on collections and graphs, and logical operations in general.

Lists of built-ins

Built-ins are denoted by a controlled IRI defined in one of the core namespaces:

• Crypto – https://www.w3.org/2000/10/swap/crypto#,
• List – https://www.w3.org/2000/10/swap/list#,
• Log – https://www.w3.org/2000/10/swap/log#,
• Math – https://www.w3.org/2000/10/swap/math#,
• String – https://www.w3.org/2000/10/swap/string#, and
• Time – https://www.w3.org/2000/10/swap/time#.

Simple Builtins

As a simple example, the rule below uses the `math:quotient` builtin to calculate a person's height in meters:

An N3 builtin is used as the predicate in an N3 builtin statement, where the subject and object act as input or output arguments. In the example above, the second triple constitutes a builtin statement: the subject is the input, as `math:quotient` calculates the quotient of the subject collection elements (i.e., the person's height in cm and 100); the object constitutes the output, as the result is then bound to the object variable `?m`.

Builtins with Multiple Results

N3 builtins can generate multiple results. Below, we use the `list:iterate` builtin to iterate over collection elements, and subsequently constructs a string for each element:

The `list:iterate` builtin iterates over all elements in the subject collection (`?finalists`). For each element, it binds its index, and the element itself, to the variables in the object collection (`?i` and `?finalist`, respectively). Hence, the `list:iterate` builtin generates multiple sets of bindings for the `?i` and `?finalist` variables:
( ?i = 1, ?finalist = :flash )
( ?i = 2, ?finalist = :superman )
( ?i = 3, ?finalist = :spiderman )

For each set of bindings, the `string:concatenation` builtin concatenates the resources in the subject collection, and binds the result to the object variable (`?entry`). This will lead to the following object values:
"`1. :flash`" , "`2. :superman`" , and "`3. :spiderman`"

A builtin statement can be seen as a triple pattern that, for each builtin result, yields one or more "matching" triples depending on the builtin. For the example above:
( :flash :superman :spiderman ) list:iterate ( 1 :flash ) .
( :flash :superman :spiderman ) list:iterate ( 2 :superman ) .
( :flash :superman :spiderman ) list:iterate ( 3 :spiderman ) .

As with a SPARQL query, for each "matching triple", a join is attempted with the remaining triples in the rule premise. Hence, for each matching triple, the `string:concatenation` builtin statement is evaluated. Finally, for each consistent set of variable bindings, the rule conclusion is instantiated and inferred.

Scoped Negation as Failure (SNAF)

N3 builtins can also operate on a local graph term or even an entire N3 document. The `log:collectAllIn`, `log:forAllIn`, and `log:notIncludes` builtins are logical operators that support a negation-as-failure scoped on the builtin statement object: the object can be a graph term or a blank node, in which case the current document is the scope. For instance, the rule below uses `log:collectAllIn` to collect all of spiderman's defeated villains found in the current document:

• a variable of which the values will be collected (`?enemy`),
• a where clause with triple patterns that constrain this variable, and
• a variable bound to the resulting collection of values (`?enemies`).

The example below uses `log:forAllIn` to determine whether a super-hero's identity is safe:

In the two examples above, the blank node object `_:t` indicates the current N3 document as scope. Alternatively, a graph term can be used as the scope as well. This is illustrated in the `log:notIncludes` example below.

The `log:notIncludes` builtin checks whether the given scope does not include a given clause. The example below uses a graph term as scope, instead of the current N3 document, as was the case for the prior two examples. The rule finds any of spiderman's enemies who have not been defeated, at least, as reported by the Daily Bugle:

For each of spiderman's enemies (`?enemy`), the rule checks whether the graph term `?graph`, as reported by the `:daily_bugle`, does not include any statement where the enemy has been defeated. If so, we infer that this enemy is undefeated, in this case, `:sandman`.

The counterpart of `log:notIncludes` is `log:includes`, which checks whether the given object scope includes a given clause.

Access Online Knowledge

To dynamically retrieve online knowledge within an N3 rule, log:semantics and log:conclusion builtins allow pulling in, parsing, and reasoning over logical expressions from online sources.

In the rule below, the `log:semantics` builtin retrieves an online source and subsequently parses it a graph term:

The `log:conclusion` builtin allows generating the closure of a given graph term, i.e., extending the graph with all applicable rule inferences. This includes graph terms retrieved and parsed from online sources. For example:

Resource Paths

Similar to SPARQL property paths, N3 resource paths concisely express paths between resources, when intermediary resources on the path are not relevant. In practice, resource paths are most useful in N3 rules.

A resource path starts from a subject resource, followed by one or more predicates; each predicate is separated by a directional indicator to follow the predicate either forward (`!`) or in reverse (`^`). For example, the following example describes the city of Joe's mother's office's address:

In this example, the intermediary resources — Joe's mother, her office, and its address — are not described or referenced further, so the more concise resource path syntax can be used.

The expansion of this shorthand syntax uses blank nodes to express the path between the two resources. The example above is equivalent to the following (using blank node identifiers for clarity):

In other words, each predicate in resource path is expanded into a statement, with as subject either the starting resource, or prior blank node object; and as object a newly minted blank node.

Relations can also be followed in reverse using the reverse (`^`) indicator. The following example, starting from `joe`, follows the `hasMother` predicate to Joe's mother, and then follows the `hasMother` predicate in reverse (thus pointing to someone who has the same mother):

This could equally well be represented by the more verbose:

In SPARQL, a property path is used in the predicate position to describe a string of relationships between a subject and an object resource. In contrast, an N3 resource path is most often used in the subject or object position. Using a resource path in the predicate position, although technically allowed, is often a mistake. For instance, the following N3 resource path:
    `:joe :hasAddress!:hasCity "Metropolis" .`
Would lead to the following expansion:
    `:joe _:bn_1 "Metropolis" .`
    `:hasAddress :hasCity _:bn_1 .`
Which is likely not the intention of the author.