rustdl 0.4.2__tar.gz → 0.4.3__tar.gz

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

@@ -1018,7 +1018,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -1038,7 +1038,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cb"
-version = "0.4.2"
+version = "0.4.3"
 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.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -1061,7 +1061,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1075,7 +1075,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1085,7 +1085,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1096,7 +1096,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "anyhow",
  "dashmap",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1130,7 +1130,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2556,7 +2556,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.4.2 → rustdl-0.4.3}/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.3"
 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.3" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.4.3" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.4.3" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.4.3" }
+owl-dl-cb = { path = "crates/owl-dl-cb", version = "0.4.3" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.4.3" }
 
 horned-owl = { version = "1.4", default-features = false }
 

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

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

{rustdl-0.4.2 → rustdl-0.4.3}/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.3}/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.3/crates/owl-dl-py/src/queries.rs

@@ -0,0 +1,182 @@
+//! 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)
+}
+
+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)?)?;
+    Ok(())
+}

rustdl-0.4.3/crates/owl-dl-py/tests/python/test_queries.py

@@ -0,0 +1,171 @@
+import rustdl
+import pytest
+
+
+def test_is_consistent_true(fixtures_dir):
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+    assert rustdl.is_consistent(str(fixture)) is True
+
+
+def test_is_class_satisfiable_true(fixtures_dir):
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+    assert rustdl.is_class_satisfiable(str(fixture), "http://t/Person") is True
+
+
+def test_is_subclass_of_direct(fixtures_dir):
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+    assert rustdl.is_subclass_of(str(fixture), "http://t/Adult", "http://t/Person") is True
+
+
+def test_is_class_satisfiable_unknown_class_raises(fixtures_dir):
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+    with pytest.raises(rustdl.UnknownClassError):
+        rustdl.is_class_satisfiable(str(fixture), "http://t/NonExistent")
+
+
+def test_is_instance_of_simple(fixtures_dir):
+    # p1_direct_bot has ClassAssertion(:Unsat :a)
+    fixture = fixtures_dir / "abox" / "p1_direct_bot.ofn"
+    assert rustdl.is_instance_of(str(fixture), "http://t/Unsat", "http://t/a") is True
+
+
+def test_instances_of_simple(fixtures_dir):
+    fixture = fixtures_dir / "abox" / "p1_direct_bot.ofn"
+    instances = rustdl.instances_of(str(fixture), "http://t/Unsat")
+    assert "http://t/a" in instances
+
+
+def test_realize_returns_dict(fixtures_dir):
+    fixture = fixtures_dir / "abox" / "p1_direct_bot.ofn"
+    realization = rustdl.realize(str(fixture))
+    assert isinstance(realization, dict)
+    assert "http://t/a" in realization
+    assert isinstance(realization["http://t/a"], list)
+
+
+def test_disjoint_classes(tmp_path):
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(Class(:A)) Declaration(Class(:B))\n"
+        "  DisjointClasses(:A :B))\n"
+    )
+    pairs = rustdl.disjoint_classes(str(p))
+    assert ("http://ex/#A", "http://ex/#B") in pairs or ("http://ex/#B", "http://ex/#A") in pairs
+
+
+def test_object_property_hierarchy_direct_subsumption(tmp_path):
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(ObjectProperty(:r)) Declaration(ObjectProperty(:s))\n"
+        "  SubObjectPropertyOf(:r :s))\n"
+    )
+    _equivalent_groups, direct_subsumptions = rustdl.object_property_hierarchy(str(p))
+    assert ("http://ex/#r", "http://ex/#s") in direct_subsumptions
+
+
+def test_different_individuals(tmp_path):
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(Class(:A)) Declaration(Class(:B))\n"
+        "  Declaration(NamedIndividual(:a)) Declaration(NamedIndividual(:b))\n"
+        "  DisjointClasses(:A :B)\n"
+        "  ClassAssertion(:A :a) ClassAssertion(:B :b))\n"
+    )
+    pairs = rustdl.different_individuals(str(p))
+    assert ("http://ex/#a", "http://ex/#b") in pairs or ("http://ex/#b", "http://ex/#a") in pairs
+
+
+def test_different_individuals_disjoint_types_is_complete(tmp_path, recwarn):
+    # Same disjoint-types shape as test_different_individuals: the extension
+    # probe resolves the (a, b) pair well within the 1s per-pair deadline, so
+    # `incomplete` stays False and no IncompleteQueryWarning is raised — the
+    # honesty signal is observable by its ABSENCE here.
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(Class(:A)) Declaration(Class(:B))\n"
+        "  Declaration(NamedIndividual(:a)) Declaration(NamedIndividual(:b))\n"
+        "  DisjointClasses(:A :B)\n"
+        "  ClassAssertion(:A :a) ClassAssertion(:B :b))\n"
+    )
+    rustdl.different_individuals(str(p))
+    assert not any(
+        issubclass(w.category, rustdl.IncompleteQueryWarning) for w in recwarn.list
+    )
+
+
+def test_same_individuals(tmp_path):
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(ObjectProperty(:r))\n"
+        "  Declaration(NamedIndividual(:a)) Declaration(NamedIndividual(:b))\n"
+        "  Declaration(NamedIndividual(:c))\n"
+        "  FunctionalObjectProperty(:r)\n"
+        "  ObjectPropertyAssertion(:r :a :b) ObjectPropertyAssertion(:r :a :c))\n"
+    )
+    groups = rustdl.same_individuals(str(p))
+    assert any(
+        "http://ex/#b" in group and "http://ex/#c" in group for group in groups
+    )
+
+
+def test_same_individuals_extension_probe_warns_incomplete(tmp_path):
+    # Same fixture as test_same_individuals: :a is not related to :b/:c by the
+    # sound-complete seed (SameIndividual + functional-forced merge), so
+    # resolving (a, b) / (a, c) requires an extension probe — which always
+    # marks the result `incomplete`, per SameIndividuals::incomplete's
+    # doc ("true iff ... ANY extension probe ... was consulted").
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(ObjectProperty(:r))\n"
+        "  Declaration(NamedIndividual(:a)) Declaration(NamedIndividual(:b))\n"
+        "  Declaration(NamedIndividual(:c))\n"
+        "  FunctionalObjectProperty(:r)\n"
+        "  ObjectPropertyAssertion(:r :a :b) ObjectPropertyAssertion(:r :a :c))\n"
+    )
+    with pytest.warns(rustdl.IncompleteQueryWarning):
+        groups = rustdl.same_individuals(str(p))
+    assert any(
+        "http://ex/#b" in group and "http://ex/#c" in group for group in groups
+    )
+
+
+def test_object_property_values(tmp_path):
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(ObjectProperty(:r))\n"
+        "  Declaration(NamedIndividual(:a)) Declaration(NamedIndividual(:b))\n"
+        "  SymmetricObjectProperty(:r)\n"
+        "  ObjectPropertyAssertion(:r :a :b))\n"
+    )
+    triples = rustdl.object_property_values(str(p))
+    assert ("http://ex/#b", "http://ex/#r", "http://ex/#a") in triples
+
+
+def test_data_property_values(tmp_path):
+    p = tmp_path / "o.ofn"
+    p.write_text(
+        "Prefix(:=<http://ex/#>)\n"
+        "Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)\n"
+        "Ontology(<http://ex/>\n"
+        "  Declaration(DataProperty(:dp))\n"
+        "  Declaration(NamedIndividual(:a))\n"
+        "  DataPropertyAssertion(:dp :a \"5\"^^xsd:integer))\n"
+    )
+    quads = rustdl.data_property_values(str(p))
+    assert any(
+        q[0] == "http://ex/#a" and q[1] == "http://ex/#dp" for q in quads
+    )

{rustdl-0.4.2/crates/owl-dl-saturation → rustdl-0.4.3/crates/owl-dl-reasoner}/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`