Home

Awesome

Reasonable

Nightly Build Build PyPI version

An OWL 2 RL reasoner with reasonable performance

Performance

Comparing performance of reasonable with OWLRL and Allegro. Evaluation consisted of loading Brick models of different sizes into the respective reasoning engine and timing how long it took to produce the materialization. reasonable is about 7x faster than Allegro and 38x faster than OWLRL on this workload.

benchmark

How to Use

Command Line Interface

You can download a static build of the command line tool here (this is automatically built from the latest master).

Usage as follows:

$ reasonable -h
An OWL 2 RL reasoner with reasonable performance

Usage: reasonable [OPTIONS] <INPUT_FILES>...

Arguments:
  <INPUT_FILES>...  

Options:
  -o, --output-file <OUTPUT_FILE>  [default: output.ttl]
  -h, --help                       Print help
  -V, --version                    Print version

Example:

$ reasonable example_models/ontologies/Brick.n3 example_models/small1.n3 -o myout.ttl
[2023-07-04T15:31:52Z INFO  reasonable] Loading file example_models/ontologies/Brick.n3
[2023-07-04T15:31:52Z INFO  reasonable::reasoner] Loaded 14803 triples from file example_models/ontologies/Brick.n3
[2023-07-04T15:31:52Z INFO  reasonable] Loading file example_models/small1.n3
[2023-07-04T15:31:52Z INFO  reasonable::reasoner] Loaded 14 triples from file example_models/small1.n3
[2023-07-04T15:31:52Z INFO  reasonable] Starting reasoning
[2023-07-04T15:32:11Z INFO  reasonable] Reasoning completed in 18.66sec
[2023-07-04T15:32:11Z INFO  reasonable] Writing to myout.ttl

Python

To facilitate usage, we use the pyo3 project to generate Python 3.x bindings to this project. Installing these should be as easy as pip install reasonable.

See also the brickschema package for working with Brick models. The package provides a generic interface to this reasoner and several others.

Usage looks like:

import reasonable

# import triples from an rdflib Graph
import rdflib
g = rdflib.Graph()
g.parse("example_models/ontologies/Brick.n3", format="n3")
g.parse("example_models/small1.n3", format="n3")

r = reasonable.PyReasoner()
r.from_graph(g)
triples = r.reason()
print("from rdflib:", len(triples))

# import triples from files on disk
r = reasonable.PyReasoner()
r.load_file("example_models/ontologies/Brick.n3")
r.load_file("example_models/small1.n3")
triples = r.reason()
print("from files:", len(triples))

Rust

See Rust docs

Example of usage from Rust:

use ::reasonable::owl::Reasoner;
use std::env;
use std::time::Instant;
use log::info;

fn main() {
    env_logger::init();
    let mut r = Reasoner::new();
    env::args().skip(1).map(|filename| {
        info!("Loading file {}", &filename);
        r.load_file(&filename).unwrap()
    }).count();
    let reasoning_start = Instant::now();
    info!("Starting reasoning");
    r.reason();
    info!("Reasoning completed in {:.02}sec", reasoning_start.elapsed().as_secs_f64());
    r.dump_file("output.ttl").unwrap();
}

OWL 2 Rules

Using rule definitions from here.

TODO: implement RDF/RDFS entailment semantics as described here

Note: haven't implemented rules that produce exceptions; waiting to determine the best way of handling these errors.

Equality Semantics

CompletedRule nameNotes
noeq-refimplementation is very inefficient; causes lots of flux
yeseq-sym
yeseq-trans
yeseq-rep-s
yeseq-rep-p
yeseq-rep-o
noeq-diff1throws exception
noeq-diff2throws exception
noeq-diff3throws exception

Property Axiom Semantics

CompletedRule nameNotes
noprp-ap
yesprp-dom
yesprp-rng
yesprp-fp
yesprp-ifp
yesprp-irpthrows exception
yesprp-symp
yesprp-asypthrows exception
yesprp-trp
yesprp-spo1
noprp-spo2
yesprp-eqp1
yesprp-eqp2
yesprp-pdwthrows exception
noprp-adpthrows exception
yesprp-inv1
yesprp-inv2
noprp-key
noprp-npa1throws exception
noprp-npa2throws exception

Class Semantics

CompletedRule nameNotes
yescls-thing
yescls-nothing1
yescls-nothing2throws exception
yescls-int1
yescls-int2
yescls-uni
yescls-comthrows exception
yescls-svf1
yescls-svf2
yescls-avf
yescls-hv1
yescls-hv2
nocls-maxc1throws exception
nocls-maxc2
nocls-maxqc1throws exception
nocls-maxqc2throws exception
nocls-maxqc3
nocls-maxqc4
nocls-oo

Class Axiom Semantics

CompletedRule nameNotes
yescax-sco
yescax-eqc1
yescax-eqc2
yescax-dwthrows exception
nocax-adcthrows exception

Other

Development Notes

To publish new versions of reasonable, tag a commit with the version (e.g. v1.3.2) and push the tag to GitHub. This will execute the publish action which builds an uploads to PyPi.