Notation3, or "N3" as it is more commonly known, is a shorthand non-XML serialization of RDF, designed with human-readability in mind. According to the Notation3 Specification, it was created as an experiment in optimizing the "expression of data and logic in the same language".
The format is being developed by Tim Berners-Lee, with input from Dan Connolly at al.
Apart from the DesignIssues Notation3 specification, the only other substantive piece of documentation—and by far the most popular—is the Notation3 Primer, which is maintained alongside the main N3 codebase.
N3 has been well received for its "scribblability", because it is much more compact and readble than XML RDF, and because it forms a good introduction into many key principles of the Semantic Web.
Some people are opposed to N3, however, because the stability of the language in the long term is not known, there are some i18n issues (which are being resolved), and a notable lack of analogies for various features of N3 in XML RDF.
At the moment, the best tools for Notation3 are available in Python. The so called Semantic Web Area for Play (SWAP) is the development page for most of these, linking to Notation3.py and CWM (pronounced "coom", with a short "oo"!). There are some other minor tools as well, for example the tab delimited to Notation3 python hack.
I did a long survey of local N3 grammars, culminating with The Great QName Survey; the survey exposed the great inconsistencies between the various implementations of N3.
Closed World Machine is a query machine for Notation3 that recognizes a few logical primitives. CVS for CWM and the related modules, the SWAP main page, the official CWM documentation, and my own guide to CWM are available.
Try SWAP: Notation3 examples and test (CVS). The SWAD page links to some more.
The regression test and associated N3 files still remain the best N3 test suite to date.
The following are some issues that people run into when they've been playing with N3 for a while, and aren't addressed in the Notation3 specification or the Primer. A level of understanding compatible with those who have read the N3 Primer is required for some of these FAQs.
:- token used for?<> and
this?Good questions. TimBL has noted several times—including in the DesignIssues document, #rdfig, and the SWAP code—that Notation3 should have the MIME type "application/n3". However, this MIME type has not been registered, and as far as I know, no N3 files are currently served from an HTTP server using this MIME type.
As for telling whether something is an N3 file, this is also a difficult thing to do, although sniffing for strings such as "@prefix" and "<#>" give you a fairly good indication. Also, if the following is the first line of a file, then you can be fairly sure that it's N3:-
<> a <http://www.w3.org/2000/10/swap/log#N3Document> .
Caution! These are heuristics only. CWM used to search for the string "xmlns" in a file to determine whether it was XML/RDF or Notation3. It decided that all files with "xmlns" in them were XML. This worked quite well until Dan Brickley decided to buy the xmlns.com domain name, and use it for the namespace of his highly popular FOAF application—as you can guess, this caused CWM to break.
The standard file extension for N3 is ".n3".
You may often see things like the following:-
:Bob :brothers (:Jim :Mark :Ian) .
The parenthetical expression is a DAML list, and is equivalent to:-
[ daml:first :Jim;
daml:rest [ daml:first :Mark;
daml:rest [ daml:first :Ian;
daml:rest daml:nil ] ] ] .
as you can tell, the shorthand syntax is very useful indeed. Note that
daml:nil (which is neither a property nor a class) is the term for the empty
list: ().
:- token used for?The ":-" token is a bit of syntax that de-anonimizes a blank node. For example, the following:-
[ :- :x; :y :z ] .
is just a syntactic "shortcut"—and therefore completely equivalent to—the following (noting that the [] returns an anonymous node):-
:x :y :z .
This method can be very useful when, for example, wanting to carry on statements where the object of one triple is the subject of another triple.
:W3C :homepage [ :- <http://www.w3.org/>;
:title "Homepage of the W3C" ] .
Quoth DanC:-
21:27:11 <DanC> on :- ... I restricted it to { :tim knows [ :- :dan; a :CoolGuy.]}.
[...]
21:33:09 <DanC> here's the example that motivated my :- hacking:
21:33:10 <DanC> :libby :says
21:33:10 <DanC> { :dan :says
21:33:10 <DanC> { [ :- :her; is :ex of :dan ] [ rdfs:subPropertyOf :told; :to :dan]
21:33:11 <DanC> { [is :mom of [ is :friend of :her]] :workedFor :theNation }
21:33:11 <DanC> } }.
21:33:21 <DanC> # libby says that dan says that dan's ex's told him that a friend's mom
used to work for the nation
- http://ilrt.org/discovery/chatlogs/rdfig/2001-04-19.txt
Note, by the way, that this could have been expressed as:-
:libby :says
{ :dan :says
{ :her is :ex of :dan; [ rdfs:subPropertyOf :told; :to :dan ]
{ [ is :mom of [ is :friend of :her ] ] :workedFor :theNation }
} }.
Personally, I'd prefer using an "iso" keyword instead of ":-".
<> and
this?<> always refers to the URI of the containing document. "this" is a keyword that identifies the root formula of the document; the relationship between the two can be expressed as:-
<> log:semantics this .
The two are by no means equivalent. <> will always identify some kind of document, and "this" will always identify a set of statements, i.e. a formula.
Note that quantification in N3 was previously achieved by quantifying over the document, but is now achieved by quantifying over the root formula. These changes were all documented in TimBL's email.
The main effect of this is that where one has said "<> log:forAll :x, :y, :z" one must use the keywpord "this" instead of "<>" to refer to the current context instead of the current document. The parsers currently generate an id "#_formula" for the context but one must NOT rely on that.
Note that CWM has a habit of reserving fragment IDs within the current document for its own purposes! It appears from the llyn.py source code that "$" was considered for a while instead of the keyword "this":-
- Introduce this or $ to indicate the current context
- Introduce a difference between <> and $ in that <> log:parsesTo $ .
serialised subPropertyOf serialisedAs
[Note also that log:parsesTo was renamed log:semantics (it was log:resolvesTo for a while, and still works using that property in cwm.py v 1.97 2002/07/06).]
(cf. the definition of formulae in the N3 primer).
I've found that it's quite easy to get along without having URIs for formulae, but on the other hand APIs often need to be able to associate a formula with (perhaps) the location of the document that the formula was obtained from. CWM does this by using the fragment ID #_formula in the document. This results in breakages when #_formula is being used for something else, and CWM shouldn't really reserve terms in that way.
[...] Can they [formulae] be given an id? You can assert that any object is equivalent to (=) a given context. However, it is the contexts which define a context. If one could label it in one place then one would want to be able to label it in more than one. I'm not sure whether this is wise. Let's try it with no IDs on contexts as in the N3 syntax. There would be the question of in which context the assertion wa made that the URI was a label for the expression. You couldn't just treat it as part of the machinery as we do for URI of a regular thing.
CWM has also been known to output triples such as:-
<blargh.n3#_formula> :- {
this log:forSome <blargh.n3#_gy> .
<blargh.n3#x> <blargh.n3#_gy> "z" .
} .
Which implies that :- can be used to label formulae using the URI for the subject and the contents for the object. However, CWM hasn't produced this sort of output for quite a while (since around cwm.py v 1.82 2001/11/15), and note that when you feed something like that back through it, it doesn't like it:-
$ n3s -s ':x :- { :p :q :r }' | cwm
#Processed by Id: cwm.py,v 1.97 2002/07/06 12:52:02 timbl Exp
Traceback (most recent call last): [...]
File "/home/newswap/2000/10/swap/llyn.py", line 1087, in storeQuad
if context.statementsMatching(pred, subj, obj):
AttributeError: Fragment instance has no attribute 'statementsMatching'
Well, theoretically, RDF is just an ANDing of lots of statements, and if we introduced NOT we could NAND our way into an OR construction... but other methods have been suggested.
Check out: Semantic Web Toolbox, and:-
<sbp> how would you express OR now? I thought of using an Alt bag (I
thought was was what it was meant to do), e.g. [ a rdf:Alt; rdf:_1 { :Bob
a :Fish }; rdf:_2 { :Bob a :Dog } ] .
[...]
<tim> I would say something like ( :F :G :H ) a :OR.
The @prefix directive in Notation3 is required by a parser when using QNames, the proof being that using directives in the RDF graph is not a suitable alternative. Here are a list of the suggested alternatives, and reasons why they don't work:-
First idea: one could declare a unique and unambiguous subproperty of rdfs:label to use for labelling namespaces with a literal.
u:nsLabel a daml:UniqueProperty, daml:UnambiguousProperty;
rdfs:subPropertyOf rdfs:label; rdfs:range rdfs:Literal .
however, this won't scale since it:-
In any case, the @prefix directive in Notation3 is a local thing, and there's no reason why a binding in the graph shouldn't be associated with a specific document:-
<> u:usesNamespaceBinding ("rdfs" <http://.../rdf-schema#>) .
Here, consider that u: itself must be bound to a "special" namespace in order for it to be recognized.
<> u:usesNamespaceBinding ("u" <http://.../n3syntax#>) .
An N3 processor would need to parse and extract the information from the document in order to parse and extract the information from the document (in order to...). In other words, you can't go putting information in the graph that is vital to the parsing and correct interpretation of the document.
The alternative here is to use a special Notation3 keyword for the binding:-
<> usesNamespaceBinding ("rdfs" <http://.../rdf-schema#>) .
the next problem that comes up is the old Semantic Web issue of where to find the information. Suppose that in document <a.n3> you have:-
rdfs:comment rdfs:label "comment" .
and in <b.n3> you have:-
<a.n3> usesNamespaceBinding ("rdfs" <http://.../rdf-schema#>) .
It fails for the obvious reason: the information about namespace bindings must always be available to the parser at parse time. One could come up with a usesNamespacesDeclaredInFile(s) keyword, but its use would have to be required, and that would be unenforcable and far more trouble than it's worth.
In CWM, you can. For example:-
$ echo '@prefix _: <#> . _:x _:y _:z .' | cwm
#Processed by Id: cwm.py,v 1.97 2002/07/06 12:52:02 timbl Exp
@prefix : <#> .
:x :y :z .
However, whether this should be standard for N3 is not clear. This is one of the many little implementation points of N3 where one just has to "guess", or survey the range of existing implementations and grammars. The Design Issues Notation3 "specification" lists "_" under prefix, with the note "(special ntuples hack. Everything in _ namespace is implictly existentially qualified at the outermost scope)". In fact, whether _:x style bNodes are quantified over the outermost scope or just their parent scope is also a point of some contention.
log:rawType gives the type of a subject as a node. For example, CWM would be happy with these triples (more precisely: they would be evaluated as "true" in a rule antecedent):-
"x" log:rawType log:String . <#x> log:rawType log:Other .
It is a magic predicate, and breaks when you feed in rules about DAML equivalence. Observe:-
$ n3s -s '{ ?p = ?x . ?p ?q ?r } => { ?x ?q ?r } . { ?x = ?y;
log:rawType ?z } => { ?x :rawType ?z } . "blargh" = <#x> .
<#x> = "blargh"' | cwm --think
#Processed by Id: cwm.py,v 1.99 2002/07/31 23:19:26 timbl Exp
"blargh" :rawType log:Literal, log:Other;
= "blargh", :x .
:x :rawType log:Literal, log:Other;
= "blargh", :x .
unless log:Literal and log:Other are considered to intersect, which is inconsistent with the way that log:rawType is evaluated in rule antecedents.
For this reason, you should only use this property (and its cousins: log:uri, log:racine, and log:stringOutput) with caution and a pinch of salt.
In a word: no. There are various features of Notation3 that are not present in XML RDF. Here's GabeW and DanC on the subject:-
- GabeW: Second question is whether (assuming that you can) there is at least one way to express every N3 expression (assuming in some sort of canonical form) in RDF/XML and vice versa
- DanC: there are various corner cases where conversion breaks down; e.g. { <sub> <funky-pred/> <obj> } can't be written in RDF 1.0 syntax. and I thought {} was short-hand for reification, but TimBL hasn't made up his mind about that yet.
- GabeW: OK, so N3 is a "in-flight" thing..
- DanC: absolutely. N3 was a hair-brained idea last summer; it became a one-night hack last October. it's had maybe a few dozen man-hours put it into it by now.
- GabeW: pretty good for a one night hack - I mean its pretty concise and fairly precise.
- DanC: yeah... I think it started with TimBL's frustration that RDF 1.0 syntax doesn't have, at its core, the equivalent of <subj> <pred> <obj>. i.e. no way to just write the three URIs without a namespace for the predicate or anything like that.
Also: Alternative design choices in Notation3.
"RDF Path" is TimBL's joke name for being able to traverse graphs by reducing the syntax required for chaining sets of statements together with anonymous nodes. For example:-
"Le Petit Prince"^:fr^:title.:author :name "Fred" .
is short for:-
[ is :author of [ :title [ :fr "Le Petit Prince" ] ] ] :name "Fred" .
Personally, I think that the syntax offers little in the way of advantage to users, and is quite a burden on N3 parsers. I spent a while implementing it in afon, and I think that even the advantage of LTR parsing over RTL is not all that evident. I prefer "$" and "%" to "." and "^". Tim prefers the latter. In a perfect (i.e. bijan dominated) world, we'd all be using parens, apparently. BTW, the scary ':boss$:wife$:age = "7" .' example from the 2002-07-17 #rdfig logs was a result of reducing a larger test case and not realising the new semantics; think of the age in dog years, perhaps.
The @keyword, @use and @prefix default declarations allow one to carve out a space of keywords in a particular Notation3 file. Notation3 already reserves some keywords, such as "a", and "this". It also has a number of non-name component symbols such as "=" and ":-" etc. The new declarations enable one to extend the keywords in a consistent manner, but do not allow you to add new non-name component symbols.
The @keyword declaration would let the parser know which keywords from the default N3 space the user wants to use. The @use declaration would enable one to import a keyword from a namespace. The @prefix default construct would simply let people say that any keywords that aren't declared in the @keyword or @use spaces are in this space. Actually, "@prefix default" used to be a part of Notation3, but was removed.
There would be a particular cascade (order of precedence) for the keyword spaces. In decending order of importance:-
For example:-
