Subject, verb and object

All knowledge is just a set of statements

<#pat> <#knows> <#jo> .

### in classical logic: knows(pat,jo)

Everything is identified by URI
Here a local URI but could point to ANY document

Verb known as predicate in the statement
The thing you use a predicate is a Property.
Don't forget the period.

Object can be literal

<#pat> <#knows> <#jo> .
<#pat> <#age> 24 .

Note: noun form "age" preferred to the verb style "knows" for predicates.

Saving space: the comma and semicolon

<#pat> <#child>  <#al>, <#chaz>, <#mo> ;
       <#age>    24 ;
       <#eyecolor> "blue" .

Comma: Here comes another object for same subject & predicate
Semicolon: here comes another predicate for same subject.
Aim? Easy scribbling of data.

Data .. e.g. a table

	age	eyecolor
pat	24	blue
al	3	green
jo	5	green


  <#pat>   <#age> 24;  <#eyecolor> "blue" .
  <#al>    <#age>  3;  <#eyecolor> "green" .
  <#jo>    <#age>  5;  <#eyecolor> "green" .

Unnamed things: Square brackets

<#pat> <#child> [ <#age> 4 ] , [ <#age> 3 ].

### in classical logic: ∃x ∃y child(pat,x) ∧ child(pat,y) ∧ age(x,4) ∧ age(y,3)

Note:

Words used as IDs have no actual meaning.
Unnamed nodes can't be used elsewhere.
If things are names, make the name explicit

  [ <#name> "Pat"; <#age> 24;  <#eyecolor> "blue"  ].
  [ <#name> "Al" ; <#age>  3;  <#eyecolor> "green" ].
  [ <#name> "Jo" ; <#age>  5;  <#eyecolor> "green" ].

Local concept

<> <#title>  "A simple example of N3".

Who or what knows what <#title> is?

Shared concept

<> <http://purl.org/dc/elements/1.1/title>
 "Primer - Getting into the Semantic Web and RDF using N3".

To save space:

@prefix dc:  <http://purl.org/dc/elements/1.1/> .
<> dc:title
  "Primer - Getting into the Semantic Web and RDF using N3".

Note

No <> used when prefixed identifier
Typically prefix stands for eveything up to including a "#"
Dublin core example alas does not give RDF schema directly: no "#"

Making vocabularies

A set of shared concepts
Properties are things to use as predicates (verbs)
Classes can be the type of an object

rdf:type is just a property, abbrevaiated to "a" in N3
You can invent them and describe Properties and Classes.

Equivalent:

:Person rdf:type  rdfs:Class
:Person a rdfs:Class.

which we could use with data;

:Pat a :Person.

Examples: class and property

:Woman a rdfs:Class; rdfs:subClassOf :Person .

and a property:

:sister a rdf:Property.

Something about the Property :sister::

:sister rdfs:domain :Person;
        rdfs:range :Woman.

Use:

:Pat  :sister  :Jo.

Convention:

Class ids start with capital, Property ids with lowercase

Rules Are Just Statements


#   subject        verb        object
#=============  ==========    ==============
{ ?x :son ?y }      =>        { ?y a :Male }.
{ ?x :son ?y }  log:implies   { ?y a :Male }.

### in classical logic: ∀x ∀y son(x,y) ⇒ male(y)

The terms in braces { } are formulas.

The rule statement relates two formulas.

More Complex Antecedent

{ ?x :son ?y.
  ?y!:age math:lessThan 15 }
 =>
{ ?y a :Boy }

More Complex Consequent

{ ?x :son ?y }
  =>
{ ?y a :Male.
  ?y :parent ?x.
  ?x a :Parent }.

EYE, an open source reasoning engine

EYE stands for "Euler Yet another proof Engine" and it is a further incremental development of Euler which is an inference engine supporting logic based proofs.
EYE is a backward-forward-backward chaining reasoner design enhanced with Euler path detection.
The Euler path detection is roughly "don't step in your own steps" to avoid vicious circles so to speak and in that respect there is a similarity with what Leonhard Euler discovered in 1736 for the Koenigsberg Bridge Problem.
The reasoning that EYE is performing is grounded in FOL (First Order Logic).
Keeping a language less powerful than FOL is quite reasonable within an application, but not for the Web, see http://www.w3.org/DesignIssues/Logic.html.
Open source project hosted at https://github.com/josd/eye.

Detailed design of EYE

N3 (Notation 3) parser
N3Logic to N3P (Notation 3 P-code) compiler
EAM (Euler Abstract Machine) with Euler path detection to avoid loops and with postponed brake mechanism to run at much increased speed
proof construction using the http://www.w3.org/2000/10/swap/reason vocabulary for proofs
builtins and support predicates for the above functionalities

EYE under the hood

Here are the layers of the EYE stack:

Basic MONADIC Benchmark

       triples   cycles |         cwm         eye        jena
                        |       [sec]       [sec]       [sec]
------------------------|------------------------------------
        10,000    1,518 |      15.400       0.420       3.200
       100,000      645 |      99.860       2.190       9.310
     1,000,000      380 |   1,094.860      21.170      75.380
    10,000,000      480 |  (OutOfMem)     231.610     853.060
   100,000,000      480 |               2,640.580   9,217.800
 1,000,000,000      431 |              32,474.540  (OutOfMem)

Test environment:

Linux 4.0.5 x86_64
processor	: 0
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 1
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 2
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 3
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
MemTotal:       264163268 kB


Reference:

https://github.com/josd/bmb

Deep taxonomy benchmark

         depth |         cwm         eye      hermit       jdrew        jena
               |       [sec]       [sec]       [sec]       [sec]       [sec]
---------------|------------------------------------------------------------
            10 |       0.160       0.018       0.055       0.130       0.047
           100 |       1.050       0.022       1.040       0.200       0.422
         1,000 |      65.930       0.063       3.580       0.870       9.302
        10,000 |   7,298.000       0.482     310.510      18.680   2,597.242
       100,000 | 732,974.070       4.808  (OutOfMem)   1,875.000  (OutOfMem)
     1,000,000 |  (848 days)      48.434              (OutOfMem)


Test environment:

Linux 4.0.5 x86_64
processor	: 0
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 1
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 2
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 3
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
MemTotal:       264163268 kB


Reference:

https://web.archive.org/web/20220119222608/http://responder.ruleml.org/WellnessRules/files/WellnessRulesN3-2009-11-10.pdf

RESTdesc Composition Benchmark

        length |         cwm         eye
               |       [sec]       [sec]
---------------|------------------------
             2 |       0.188       0.029
             4 |       0.371       0.032
             8 |       1.004       0.038
            16 |       3.504       0.053
            32 |      13.968       0.085
            64 |      58.689       0.157
           128 |     251.361       0.344
           256 |   1,081.179       0.936
           512 | (MaxRecurs)       2.894
         1,024 |                   9.764


Test environment:

Linux 4.0.5 x86_64
processor	: 0
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 1
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 2
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
processor	: 3
model name	: Intel(R) Xeon(R) CPU E5-2665 0 @ 2.40GHz
MemTotal:       264163268 kB


Reference:

https://github.com/RubenVerborgh/RESTdesc-Composition-Benchmark

EYE Server by Ruben Verborgh

Online reasoning service at http://eye.restdesc.org
Open source code at https://github.com/RubenVerborgh/EyeServer

For instance the following command

curl "http://eye.restdesc.org?data=http://eulersharp.sourceforge.net/2003/03swap/socrates.n3
                &query=http://eulersharp.sourceforge.net/2003/03swap/socratesF.n3"

returns

@prefix log: <http://www.w3.org/2000/10/swap/log#>.
...

:Socrates a _:Man_1.
:Socrates a :Mortal.

EYE looking through N3 glasses

Context is Semantic Web (slides from TimBL)