bin+lib reasonable

An OWL 2 RL reasoner with reasonable performance

87 releases

0.2.1-alpha9 Nov 7, 2022
0.2.0 Oct 31, 2022
0.1.53 Feb 23, 2022
0.1.49 Oct 5, 2021
0.1.6 Feb 7, 2020

#249 in Database implementations

Download history 1/week @ 2023-10-15 11/week @ 2023-10-22 139/week @ 2023-10-29 92/week @ 2023-11-05 1/week @ 2023-11-12 2/week @ 2023-11-19 231/week @ 2023-11-26 263/week @ 2023-12-03 2/week @ 2023-12-10 87/week @ 2023-12-17 175/week @ 2023-12-24 87/week @ 2023-12-31 60/week @ 2024-01-14 80/week @ 2024-01-21 174/week @ 2024-01-28

314 downloads per month

Custom license

2.5K SLoC


Nightly Build Build PyPI version

An OWL 2 RL reasoner with reasonable 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.


How to Use


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()
triples = r.reason()
print("from rdflib:", len(triples))

# import triples from files on disk
r = reasonable.PyReasoner()
triples = r.reason()
print("from files:", len(triples))


See Rust docs

Example of usage from Rust:

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

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

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

Completed Rule name Notes
no eq-ref implementation is very inefficient; causes lots of flux
yes eq-sym
yes eq-trans
yes eq-rep-s
yes eq-rep-p
yes eq-rep-o
no eq-diff1 throws exception
no eq-diff2 throws exception
no eq-diff3 throws exception

Property Axiom Semantics

Completed Rule name Notes
no prp-ap
yes prp-dom
yes prp-rng
yes prp-fp
yes prp-ifp
yes prp-irp throws exception
yes prp-symp
yes prp-asyp throws exception
yes prp-trp
yes prp-spo1
no prp-spo2
yes prp-eqp1
yes prp-eqp2
yes prp-pdw throws exception
no prp-adp throws exception
yes prp-inv1
yes prp-inv2
no prp-key
no prp-npa1 throws exception
no prp-npa2 throws exception

Class Semantics

Completed Rule name Notes
yes cls-thing
yes cls-nothing1
yes cls-nothing2 throws exception
yes cls-int1
yes cls-int2
yes cls-uni
yes cls-com throws exception
yes cls-svf1
yes cls-svf2
yes cls-avf
yes cls-hv1
yes cls-hv2
no cls-maxc1 throws exception
no cls-maxc2
no cls-maxqc1 throws exception
no cls-maxqc2 throws exception
no cls-maxqc3
no cls-maxqc4
no cls-oo

Class Axiom Semantics

Completed Rule name Notes
yes cax-sco
yes cax-eqc1
yes cax-eqc2
yes cax-dw throws exception
no cax-adc throws exception


  • no datatype semantics for now

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.


~255K SLoC