rustdl 0.4.2__tar.gz → 0.4.4__tar.gz

{rustdl-0.4.2 → rustdl-0.4.4}/Cargo.lock

@@ -1018,7 +1018,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -1038,7 +1038,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cb"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "hashbrown 0.15.5",
  "owl-dl-core",
@@ -1046,7 +1046,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -1061,7 +1061,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1075,7 +1075,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1085,7 +1085,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1096,7 +1096,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "anyhow",
  "dashmap",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1130,7 +1130,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2556,7 +2556,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.4.2 → rustdl-0.4.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/owl-dl-core", "crates/owl-dl-saturation", "crates/owl-dl-tableau", "crates/owl-dl-datatypes", "crates/owl-dl-reasoner", "crates/owl-dl-py"]
 
 [workspace.package]
-version = "0.4.2"
+version = "0.4.4"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0 OR MIT"
@@ -15,12 +15,12 @@ keywords = ["owl", "ontology", "reasoner", "description-logic", "semantic-web"]
 categories = ["science", "data-structures"]
 
 [workspace.dependencies]
-owl-dl-core = { path = "crates/owl-dl-core", version = "0.4.2" }
-owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.4.2" }
-owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.4.2" }
-owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.4.2" }
-owl-dl-cb = { path = "crates/owl-dl-cb", version = "0.4.2" }
-owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.4.2" }
+owl-dl-core = { path = "crates/owl-dl-core", version = "0.4.4" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.4.4" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.4.4" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.4.4" }
+owl-dl-cb = { path = "crates/owl-dl-cb", version = "0.4.4" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.4.4" }
 
 horned-owl = { version = "1.4", default-features = false }
 

{rustdl-0.4.2 → rustdl-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustdl
-Version: 0.4.2
+Version: 0.4.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License

{rustdl-0.4.2 → rustdl-0.4.4}/crates/owl-dl-core/README.md

@@ -5,6 +5,7 @@
 [![license](https://img.shields.io/badge/license-Apache--2.0%20OR%20MIT-blue)](#licensing)
 [![Rust](https://img.shields.io/badge/Rust-1.88%2B-orange?logo=rust&logoColor=white)](https://www.rust-lang.org)
 [![Python](https://img.shields.io/badge/Python-3.10%2B-blue?logo=python&logoColor=white)](https://pypi.org/project/rustdl/)
+[![Protégé plugin](https://img.shields.io/badge/Prot%C3%A9g%C3%A9-plugin-blue)](protege/README.md)
 
 A **sound** OWL 2 DL (SROIQ) reasoner in Rust. Konclude-style hybrid: a
 consequence-based **saturation** engine handles the EL-ish fragment, a
@@ -175,6 +176,27 @@ Any run that hits a bound prints a prominent `INCOMPLETE` warning to stderr.
 Diagnostics: `RUSTDL_TRACE=1` (one stderr line per search/branch decision);
 `RUSTDL_COUNTERS=1` with `--features counters` (per-rule call counts).
 
+## Protégé plugin
+
+rustdl runs as a Protégé Desktop reasoner.
+
+**Install:** download `rustdl-protege-<version>.jar` from the
+[latest release](https://github.com/MaastrichtU-IDS/rustdl/releases/latest), drop
+it into Protégé's `plugins/` directory, and restart. Choose **rustdl** under
+Reasoner ▸, then Reasoner ▸ Start reasoner.
+
+**Computes (v1):** consistency, the inferred class hierarchy, unsatisfiable
+classes, and class assertions (types / instances). Property hierarchies & values,
+same/different individuals, disjointness, and complex-class-expression queries
+return empty for now.
+
+**Config** (JVM system property, else env var): `-Drustdl.bin=…` / `RUSTDL_BIN`
+for a specific binary; `-Drustdl.timeout.seconds=…` / `RUSTDL_TIMEOUT_SECONDS`
+(default 600) for the per-call timeout.
+
+Requires Protégé 5.6.x (Java 11+). Build-from-source and the full contract:
+[`protege/README.md`](protege/README.md), [`docs/protege-plugin.md`](docs/protege-plugin.md).
+
 ## Licensing
 
 Dual-licensed [Apache-2.0](LICENSE-APACHE) **OR** [MIT](LICENSE-MIT). `horned-owl`

{rustdl-0.4.2 → rustdl-0.4.4}/crates/owl-dl-core/src/clause.rs

@@ -273,14 +273,10 @@ impl Clausifier {
                 }
             }
             Axiom::DisjointUnion { class, members } => {
-                // class ≡ ⊔members, plus pairwise disjoint members.
-                let cls_concept_eq = members; // handled below via gci on the union
-                let _ = cls_concept_eq;
-                // class ⊑ ⊔members and each member ⊑ class:
-                // approximate via the union concept if present is
-                // complex; defer the equivalence half, emit the
-                // pairwise disjointness which is the load-bearing
-                // part for unsat detection.
+                // class ≡ ⊔members: pairwise disjoint members, each
+                // member ⊑ class (Horn), and the covering half
+                // class ⊑ ⊔members (a genuine disjunctive-head
+                // clause — see the design doc for #40).
                 for i in 0..members.len() {
                     for j in (i + 1)..members.len() {
                         self.next_var = X + 1;
@@ -315,6 +311,35 @@ impl Clausifier {
                         self.defer("disjoint-union-member");
                     }
                 }
+                // class ⊑ ⊔members (the previously-deferred covering
+                // half): C(X) → D1(X) ∨ … ∨ Dn(X). Sound — a genuine
+                // DisjointUnion entailment, so it can only add true
+                // subsumptions, never an FP.
+                self.next_var = X + 1;
+                let mut head = Vec::with_capacity(members.len());
+                let mut all_atomic = true;
+                for &m in members {
+                    if let Some(cid) = self.class_id_of(m) {
+                        head.push(Atom::Class(cid, X));
+                    } else {
+                        // Complex member: sound under-approximation —
+                        // defer the covering clause rather than emit
+                        // it with a missing disjunct (which would be
+                        // an unsound *narrower* union).
+                        all_atomic = false;
+                        break;
+                    }
+                }
+                if all_atomic {
+                    // Empty members ⇒ head == [] ⇒ `C ⊑ ⊥` (empty
+                    // union), matching the ⊥-clause convention.
+                    self.clauses.push(DlClause {
+                        body: vec![Atom::Class(*class, X)],
+                        head,
+                    });
+                } else {
+                    self.defer("disjoint-union-covering");
+                }
             }
             Axiom::ObjectPropertyDomain { role, domain } => {
                 // ∃role.⊤ ⊑ domain  →  role(x,y) → domain(x)

{rustdl-0.4.2 → rustdl-0.4.4}/crates/owl-dl-datatypes/README.md

@@ -5,6 +5,7 @@
 [![license](https://img.shields.io/badge/license-Apache--2.0%20OR%20MIT-blue)](#licensing)
 [![Rust](https://img.shields.io/badge/Rust-1.88%2B-orange?logo=rust&logoColor=white)](https://www.rust-lang.org)
 [![Python](https://img.shields.io/badge/Python-3.10%2B-blue?logo=python&logoColor=white)](https://pypi.org/project/rustdl/)
+[![Protégé plugin](https://img.shields.io/badge/Prot%C3%A9g%C3%A9-plugin-blue)](protege/README.md)
 
 A **sound** OWL 2 DL (SROIQ) reasoner in Rust. Konclude-style hybrid: a
 consequence-based **saturation** engine handles the EL-ish fragment, a
@@ -175,6 +176,27 @@ Any run that hits a bound prints a prominent `INCOMPLETE` warning to stderr.
 Diagnostics: `RUSTDL_TRACE=1` (one stderr line per search/branch decision);
 `RUSTDL_COUNTERS=1` with `--features counters` (per-rule call counts).
 
+## Protégé plugin
+
+rustdl runs as a Protégé Desktop reasoner.
+
+**Install:** download `rustdl-protege-<version>.jar` from the
+[latest release](https://github.com/MaastrichtU-IDS/rustdl/releases/latest), drop
+it into Protégé's `plugins/` directory, and restart. Choose **rustdl** under
+Reasoner ▸, then Reasoner ▸ Start reasoner.
+
+**Computes (v1):** consistency, the inferred class hierarchy, unsatisfiable
+classes, and class assertions (types / instances). Property hierarchies & values,
+same/different individuals, disjointness, and complex-class-expression queries
+return empty for now.
+
+**Config** (JVM system property, else env var): `-Drustdl.bin=…` / `RUSTDL_BIN`
+for a specific binary; `-Drustdl.timeout.seconds=…` / `RUSTDL_TIMEOUT_SECONDS`
+(default 600) for the per-call timeout.
+
+Requires Protégé 5.6.x (Java 11+). Build-from-source and the full contract:
+[`protege/README.md`](protege/README.md), [`docs/protege-plugin.md`](docs/protege-plugin.md).
+
 ## Licensing
 
 Dual-licensed [Apache-2.0](LICENSE-APACHE) **OR** [MIT](LICENSE-MIT). `horned-owl`

{rustdl-0.4.2 → rustdl-0.4.4}/crates/owl-dl-py/src/load.rs

@@ -1,6 +1,7 @@
 //! Parse OWL ontologies from a file path or bytes, mapping
 //! horned-owl parse errors to `ParseError`.
 
+use horned_owl::curie::PrefixMapping;
 use horned_owl::io::ParserConfiguration;
 use horned_owl::io::ofn::reader::read as read_ofn;
 use horned_owl::io::omn::reader::read as read_omn;
@@ -14,34 +15,47 @@ use std::path::Path;
 
 use crate::errors::ParseError;
 
+/// Detect the parse format from a file path's extension
+/// (`.ofn` | `.owx` | `.rdf` | `.owl` | `.omn`).
+fn format_from_path(path: &str) -> PyResult<&'static str> {
+    let ext = Path::new(path)
+        .extension()
+        .and_then(|s| s.to_str())
+        .map(str::to_ascii_lowercase);
+    match ext.as_deref() {
+        Some("ofn") => Ok("ofn"),
+        Some("owx") => Ok("owx"),
+        Some("rdf" | "owl") => Ok("rdf-xml"),
+        Some("omn") => Ok("omn"),
+        Some(other) => Err(ParseError::new_err(format!(
+            "unknown extension `.{other}` — pass format= explicitly via classify_bytes() or rename file to .ofn / .owx / .rdf / .omn"
+        ))),
+        None => Err(ParseError::new_err(format!(
+            "no extension on `{path}` — pass format= explicitly via classify_bytes()"
+        ))),
+    }
+}
+
 /// Parse an ontology from a file path. Format is auto-detected from
 /// the file extension (`.ofn` | `.owx` | `.rdf` | `.owl` | `.omn`).
 pub(crate) fn load_path(path: &str) -> PyResult<SetOntology<RcStr>> {
     let src = std::fs::read_to_string(path)
         .map_err(|e| ParseError::new_err(format!("read {path}: {e}")))?;
-    let ext = Path::new(path)
-        .extension()
-        .and_then(|s| s.to_str())
-        .map(str::to_ascii_lowercase);
-    let format = match ext.as_deref() {
-        Some("ofn") => "ofn",
-        Some("owx") => "owx",
-        Some("rdf" | "owl") => "rdf-xml",
-        Some("omn") => "omn",
-        Some(other) => {
-            return Err(ParseError::new_err(format!(
-                "unknown extension `.{other}` — pass format= explicitly via classify_bytes() or rename file to .ofn / .owx / .rdf / .omn"
-            )));
-        }
-        None => {
-            return Err(ParseError::new_err(format!(
-                "no extension on `{path}` — pass format= explicitly via classify_bytes()"
-            )));
-        }
-    };
+    let format = format_from_path(path)?;
     parse_with_format(&src, format)
 }
 
+/// Like [`load_path`], but also returns the [`PrefixMapping`] the OFN/OWX/OMN
+/// reader collected — used to resolve Manchester class-expression strings
+/// (e.g. `:A`) against the ontology's own prefixes. The RDF/XML reader does
+/// not expose a prefix map, so that path returns `PrefixMapping::default()`.
+pub(crate) fn load_path_with_pm(path: &str) -> PyResult<(SetOntology<RcStr>, PrefixMapping)> {
+    let src = std::fs::read_to_string(path)
+        .map_err(|e| ParseError::new_err(format!("read {path}: {e}")))?;
+    let format = format_from_path(path)?;
+    parse_with_format_pm(&src, format)
+}
+
 /// Parse from bytes with an explicit format string.
 pub(crate) fn load_bytes(data: &[u8], format: &str) -> PyResult<SetOntology<RcStr>> {
     let src = std::str::from_utf8(data)
@@ -49,6 +63,28 @@ pub(crate) fn load_bytes(data: &[u8], format: &str) -> PyResult<SetOntology<RcSt
     parse_with_format(src, format)
 }
 
+fn parse_with_format_pm(src: &str, format: &str) -> PyResult<(SetOntology<RcStr>, PrefixMapping)> {
+    let mut reader = Cursor::new(src);
+    let cfg = ParserConfiguration::default();
+    let result = match format {
+        "ofn" => read_ofn(&mut reader, cfg).map(|(o, pm): (SetOntology<RcStr>, _)| (o, pm)),
+        "owx" => read_owx(&mut reader, cfg).map(|(o, pm): (SetOntology<RcStr>, _)| (o, pm)),
+        // rdf::reader::read exposes no PrefixMapping; use the default (empty) one.
+        "rdf-xml" | "rdf" => {
+            read_rdf(&mut reader, cfg).map(|(o, _)| (o.into(), PrefixMapping::default()))
+        }
+        "omn" | "manchester" => {
+            read_omn(&mut reader, cfg).map(|(o, pm): (SetOntology<RcStr>, _)| (o, pm))
+        }
+        other => {
+            return Err(ParseError::new_err(format!(
+                "unknown format `{other}` — expected one of: ofn, owx, rdf-xml, omn"
+            )));
+        }
+    };
+    result.map_err(|e| ParseError::new_err(format!("parse {format}: {e}")))
+}
+
 fn parse_with_format(src: &str, format: &str) -> PyResult<SetOntology<RcStr>> {
     let mut reader = Cursor::new(src);
     let cfg = ParserConfiguration::default();

rustdl-0.4.4/crates/owl-dl-py/src/queries.rs

@@ -0,0 +1,235 @@
+//! Top-level query bindings: consistency, satisfiability, subsumption,
+//! instance checks, realization.
+
+use std::collections::HashMap;
+
+use pyo3::prelude::*;
+
+use crate::errors::reason_error_to_py;
+use crate::load;
+
+/// True iff the ontology at `path` is consistent.
+#[pyfunction]
+pub(crate) fn is_consistent(path: &str) -> PyResult<bool> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::is_consistent(&ontology).map_err(reason_error_to_py)
+}
+
+/// True iff `class_iri` is satisfiable (not ⊑ ⊥).
+#[pyfunction]
+pub(crate) fn is_class_satisfiable(path: &str, class_iri: &str) -> PyResult<bool> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::is_class_satisfiable(&ontology, class_iri).map_err(reason_error_to_py)
+}
+
+/// True iff `sub ⊑ sup` is entailed.
+#[pyfunction]
+pub(crate) fn is_subclass_of(path: &str, sub: &str, sup: &str) -> PyResult<bool> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::is_subclass_of(&ontology, sub, sup).map_err(reason_error_to_py)
+}
+
+/// True iff `individual_iri` is an instance of `class_iri`.
+#[pyfunction]
+pub(crate) fn is_instance_of(path: &str, class_iri: &str, individual_iri: &str) -> PyResult<bool> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::is_instance_of(&ontology, class_iri, individual_iri)
+        .map_err(reason_error_to_py)
+}
+
+/// Named individuals entailed to be instances of `class_iri`.
+#[pyfunction]
+pub(crate) fn instances_of(path: &str, class_iri: &str) -> PyResult<Vec<String>> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::instances_of(&ontology, class_iri).map_err(reason_error_to_py)
+}
+
+/// Map each named individual to its most-specific entailed types.
+#[pyfunction]
+pub(crate) fn realize(path: &str) -> PyResult<HashMap<String, Vec<String>>> {
+    let ontology = load::load_path(path)?;
+    let rs_realization = owl_dl_reasoner::realize(&ontology).map_err(reason_error_to_py)?;
+    Ok(realization_to_dict(&rs_realization))
+}
+
+fn realization_to_dict(realization: &owl_dl_reasoner::Realization) -> HashMap<String, Vec<String>> {
+    realization
+        .individuals()
+        .iter()
+        .map(|ind| (ind.clone(), realization.most_specific_types(ind).to_vec()))
+        .collect()
+}
+
+/// Entailed disjoint named-class pairs `(c, d)` — `C ⊓ D` is proven
+/// unsatisfiable — plus a completeness flag. Bounded by a 1s per-pair
+/// deadline. The Python-level wrapper (`__init__.py`) unpacks the tuple,
+/// warns on `incomplete`, and returns just the pair list (see
+/// `IncompleteQueryWarning`).
+#[pyfunction]
+pub(crate) fn disjoint_classes(path: &str) -> PyResult<(Vec<(String, String)>, bool)> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::disjoint_classes(&ontology, Some(std::time::Duration::from_secs(1)))
+        .map(|d| (d.pairs().to_vec(), d.incomplete()))
+        .map_err(reason_error_to_py)
+}
+
+/// Told-disjoint object property pairs `(a, b)`.
+#[pyfunction]
+pub(crate) fn disjoint_object_properties(path: &str) -> PyResult<Vec<(String, String)>> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::disjoint_object_properties(&ontology).map_err(reason_error_to_py)
+}
+
+/// Told-disjoint data property pairs `(a, b)`.
+#[pyfunction]
+pub(crate) fn disjoint_data_properties(path: &str) -> PyResult<Vec<(String, String)>> {
+    let ontology = load::load_path(path)?;
+    owl_dl_reasoner::disjoint_data_properties(&ontology).map_err(reason_error_to_py)
+}
+
+/// Inferred object property hierarchy: `(equivalent_groups, direct_subsumptions)`.
+#[pyfunction]
+#[allow(clippy::type_complexity)]
+pub(crate) fn object_property_hierarchy(
+    path: &str,
+) -> PyResult<(Vec<Vec<String>>, Vec<(String, String)>)> {
+    let o = load::load_path(path)?;
+    let c = owl_dl_reasoner::classify_object_property_hierarchy(&o).map_err(reason_error_to_py)?;
+    Ok((
+        c.equivalent_groups().to_vec(),
+        c.direct_subsumptions().to_vec(),
+    ))
+}
+
+/// Inferred data property hierarchy: `(equivalent_groups, direct_subsumptions)`.
+#[pyfunction]
+#[allow(clippy::type_complexity)]
+pub(crate) fn data_property_hierarchy(
+    path: &str,
+) -> PyResult<(Vec<Vec<String>>, Vec<(String, String)>)> {
+    let o = load::load_path(path)?;
+    let c = owl_dl_reasoner::classify_data_property_hierarchy(&o).map_err(reason_error_to_py)?;
+    Ok((
+        c.equivalent_groups().to_vec(),
+        c.direct_subsumptions().to_vec(),
+    ))
+}
+
+/// Entailed same-individual equivalence groups (asserted + functional-forced
+/// + entailed), plus a completeness flag. Bounded by a 1s per-pair deadline.
+/// See `disjoint_classes` for the tuple/wrapper convention.
+#[pyfunction]
+pub(crate) fn same_individuals(path: &str) -> PyResult<(Vec<Vec<String>>, bool)> {
+    let o = load::load_path(path)?;
+    owl_dl_reasoner::same_individuals(&o, Some(std::time::Duration::from_secs(1)))
+        .map(|s| (s.groups().to_vec(), s.incomplete()))
+        .map_err(reason_error_to_py)
+}
+
+/// Entailed different-individual pairs `(a, b)` — `{a} ⊓ {b}` is proven
+/// unsatisfiable — plus a completeness flag. Bounded by a 1s per-pair
+/// deadline. See `disjoint_classes` for the tuple/wrapper convention.
+#[pyfunction]
+pub(crate) fn different_individuals(path: &str) -> PyResult<(Vec<(String, String)>, bool)> {
+    let o = load::load_path(path)?;
+    owl_dl_reasoner::different_individuals(&o, Some(std::time::Duration::from_secs(1)))
+        .map(|d| (d.pairs().to_vec(), d.incomplete()))
+        .map_err(reason_error_to_py)
+}
+
+/// Inferred object property values `(subject, property, object)` over named
+/// individuals, plus a completeness flag. Bounded by a 1s per-pair deadline.
+/// See `disjoint_classes` for the tuple/wrapper convention.
+#[pyfunction]
+#[allow(clippy::type_complexity)]
+pub(crate) fn object_property_values(
+    path: &str,
+) -> PyResult<(Vec<(String, String, String)>, bool)> {
+    let o = load::load_path(path)?;
+    owl_dl_reasoner::inferred_object_property_values(&o, Some(std::time::Duration::from_secs(1)))
+        .map(|v| (v.triples().to_vec(), v.incomplete()))
+        .map_err(reason_error_to_py)
+}
+
+/// Inferred data property values `(subject, property, lexical, datatype)`
+/// over named individuals.
+#[pyfunction]
+#[allow(clippy::type_complexity)]
+pub(crate) fn data_property_values(path: &str) -> PyResult<Vec<(String, String, String, String)>> {
+    let o = load::load_path(path)?;
+    owl_dl_reasoner::inferred_data_property_values(&o)
+        .map(|v| v.quads().to_vec())
+        .map_err(reason_error_to_py)
+}
+
+/// Parse a Manchester-syntax class expression against the ontology's own
+/// prefix map (so e.g. `:A` resolves via the file's `Prefix(:=...)`).
+fn parse_ce(
+    ce: &str,
+    pm: &horned_owl::curie::PrefixMapping,
+    build: &horned_owl::model::Build<horned_owl::model::RcStr>,
+) -> PyResult<horned_owl::model::ClassExpression<horned_owl::model::RcStr>> {
+    horned_owl::io::omn::reader::parse_class_expression(ce, pm, build)
+        .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("class expression: {e}")))
+}
+
+/// Is `ce` satisfiable w.r.t. the ontology at `path`? Plus a completeness
+/// flag. See `disjoint_classes` for the tuple/wrapper convention.
+#[pyfunction]
+pub(crate) fn class_expression_satisfiable(path: &str, ce: &str) -> PyResult<(bool, bool)> {
+    let (o, pm) = load::load_path_with_pm(path)?;
+    let build: horned_owl::model::Build<horned_owl::model::RcStr> = horned_owl::model::Build::new();
+    let ce = parse_ce(ce, &pm, &build)?;
+    let v = owl_dl_reasoner::class_expression_satisfiable(&o, &ce).map_err(reason_error_to_py)?;
+    Ok((v.holds(), v.incomplete()))
+}
+
+/// Is `sub_ce ⊑ sup_ce` entailed w.r.t. the ontology at `path`? Plus a
+/// completeness flag. See `disjoint_classes` for the tuple/wrapper convention.
+#[pyfunction]
+pub(crate) fn class_expression_entailed_subclass(
+    path: &str,
+    sub_ce: &str,
+    sup_ce: &str,
+) -> PyResult<(bool, bool)> {
+    let (o, pm) = load::load_path_with_pm(path)?;
+    let build: horned_owl::model::Build<horned_owl::model::RcStr> = horned_owl::model::Build::new();
+    let sub_ce = parse_ce(sub_ce, &pm, &build)?;
+    let sup_ce = parse_ce(sup_ce, &pm, &build)?;
+    let v = owl_dl_reasoner::class_expression_entailed_subclass(&o, &sub_ce, &sup_ce)
+        .map_err(reason_error_to_py)?;
+    Ok((v.holds(), v.incomplete()))
+}
+
+/// Named individuals provably in `ce` w.r.t. the ontology at `path`, plus a
+/// completeness flag. See `disjoint_classes` for the tuple/wrapper convention.
+#[pyfunction]
+pub(crate) fn class_expression_instances(path: &str, ce: &str) -> PyResult<(Vec<String>, bool)> {
+    let (o, pm) = load::load_path_with_pm(path)?;
+    let build: horned_owl::model::Build<horned_owl::model::RcStr> = horned_owl::model::Build::new();
+    let ce = parse_ce(ce, &pm, &build)?;
+    let r = owl_dl_reasoner::class_expression_instances(&o, &ce).map_err(reason_error_to_py)?;
+    Ok((r.individuals().to_vec(), r.incomplete()))
+}
+
+pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(is_consistent, m)?)?;
+    m.add_function(wrap_pyfunction!(is_class_satisfiable, m)?)?;
+    m.add_function(wrap_pyfunction!(is_subclass_of, m)?)?;
+    m.add_function(wrap_pyfunction!(is_instance_of, m)?)?;
+    m.add_function(wrap_pyfunction!(instances_of, m)?)?;
+    m.add_function(wrap_pyfunction!(realize, m)?)?;
+    m.add_function(wrap_pyfunction!(disjoint_classes, m)?)?;
+    m.add_function(wrap_pyfunction!(disjoint_object_properties, m)?)?;
+    m.add_function(wrap_pyfunction!(disjoint_data_properties, m)?)?;
+    m.add_function(wrap_pyfunction!(object_property_hierarchy, m)?)?;
+    m.add_function(wrap_pyfunction!(data_property_hierarchy, m)?)?;
+    m.add_function(wrap_pyfunction!(same_individuals, m)?)?;
+    m.add_function(wrap_pyfunction!(different_individuals, m)?)?;
+    m.add_function(wrap_pyfunction!(object_property_values, m)?)?;
+    m.add_function(wrap_pyfunction!(data_property_values, m)?)?;
+    m.add_function(wrap_pyfunction!(class_expression_satisfiable, m)?)?;
+    m.add_function(wrap_pyfunction!(class_expression_entailed_subclass, m)?)?;
+    m.add_function(wrap_pyfunction!(class_expression_instances, m)?)?;
+    Ok(())
+}