rustdl 0.3.16__tar.gz → 0.3.18__tar.gz

{rustdl-0.3.16 → rustdl-0.3.18}/Cargo.lock

@@ -1018,7 +1018,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "anyhow",
  "clap",
@@ -1037,7 +1037,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cb"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "hashbrown 0.15.5",
  "owl-dl-core",
@@ -1045,7 +1045,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "anyhow",
  "clap",
@@ -1058,7 +1058,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1072,7 +1072,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1082,7 +1082,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1093,7 +1093,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1110,7 +1110,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1126,7 +1126,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2552,7 +2552,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.3.16"
+version = "0.3.18"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.3.16 → rustdl-0.3.18}/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.3.16"
+version = "0.3.18"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0 OR MIT"

{rustdl-0.3.16 → rustdl-0.3.18}/PKG-INFO

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

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-core/README.md

@@ -6,7 +6,7 @@ consequence-based **saturation** engine handles the EL-ish fragment, a
 orchestrator picks per query. Parsing and the OWL model come from
 [`horned-owl`](https://github.com/phillord/horned-owl).
 
-## Status (v0.3.12)
+## Status (v0.3.16)
 
 A working classifier, consistency checker, and instance reasoner for SROIQ(D)
 with first-class data properties. The defining property is **soundness**: every
@@ -17,10 +17,13 @@ reported subsumption is a genuine entailment.
   nothing that neither complete reasoner does.
 - **Fastest on EL.** rustdl's saturation kernel beats whelk-rs (1.4–1.9×) and ELK
   (4.5×) on galen/notgalen, deriving a sound *superset* of their closures.
-- **Competitive on DL, not the speed leader.** After recent work, most DL
-  ontologies classify within ~10–50× of Konclude (the mature C++ tableau, which
-  wins on speed); HermiT is slower still and itself DNFs on a hard tail.
-  **wine** is rustdl's one DNF (combinatorial nominal+disjunction).
+- **Competitive on DL, not the speed leader.** Most DL ontologies classify
+  within ~10–50× of Konclude (the mature C++ tableau, which wins on speed);
+  HermiT is slower still and itself DNFs on a hard tail. **wine — once rustdl's
+  one DNF (combinatorial nominal+disjunction) — now classifies soundly in ~1.6 s**
+  (a ~30× reduction from the coupled-saturation ∃-seed plus wedge search-ordering
+  work; see the [v0.3.16 snapshot](docs/perf-2026-06-27-bench-snapshot.md)). A
+  residual of ~9 idiosyncratic ORE-pilot ontologies stays hard.
 - Detects the **family** inconsistency (a consequence-based ABox-saturation
   pre-check) that the per-pair tableau alone misses.
 - **Explains *and* debugs — a full suite.** Built-in CLI commands turn rustdl into
@@ -150,6 +153,7 @@ license; no separate CLA.
 
 ## More
 
+- Latest benchmark snapshot: [`docs/perf-2026-06-27-bench-snapshot.md`](docs/perf-2026-06-27-bench-snapshot.md)
 - Reasoner comparison: [`docs/reasoner-comparison-2026-06-21.md`](docs/reasoner-comparison-2026-06-21.md)
 - Perf vs Konclude/HermiT: [`docs/perf-2026-06-08-konclude-vs-rustdl.md`](docs/perf-2026-06-08-konclude-vs-rustdl.md)
 - Completeness envelope: [`docs/fragment-completeness.md`](docs/fragment-completeness.md)

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-datatypes/README.md

@@ -6,7 +6,7 @@ consequence-based **saturation** engine handles the EL-ish fragment, a
 orchestrator picks per query. Parsing and the OWL model come from
 [`horned-owl`](https://github.com/phillord/horned-owl).
 
-## Status (v0.3.12)
+## Status (v0.3.16)
 
 A working classifier, consistency checker, and instance reasoner for SROIQ(D)
 with first-class data properties. The defining property is **soundness**: every
@@ -17,10 +17,13 @@ reported subsumption is a genuine entailment.
   nothing that neither complete reasoner does.
 - **Fastest on EL.** rustdl's saturation kernel beats whelk-rs (1.4–1.9×) and ELK
   (4.5×) on galen/notgalen, deriving a sound *superset* of their closures.
-- **Competitive on DL, not the speed leader.** After recent work, most DL
-  ontologies classify within ~10–50× of Konclude (the mature C++ tableau, which
-  wins on speed); HermiT is slower still and itself DNFs on a hard tail.
-  **wine** is rustdl's one DNF (combinatorial nominal+disjunction).
+- **Competitive on DL, not the speed leader.** Most DL ontologies classify
+  within ~10–50× of Konclude (the mature C++ tableau, which wins on speed);
+  HermiT is slower still and itself DNFs on a hard tail. **wine — once rustdl's
+  one DNF (combinatorial nominal+disjunction) — now classifies soundly in ~1.6 s**
+  (a ~30× reduction from the coupled-saturation ∃-seed plus wedge search-ordering
+  work; see the [v0.3.16 snapshot](docs/perf-2026-06-27-bench-snapshot.md)). A
+  residual of ~9 idiosyncratic ORE-pilot ontologies stays hard.
 - Detects the **family** inconsistency (a consequence-based ABox-saturation
   pre-check) that the per-pair tableau alone misses.
 - **Explains *and* debugs — a full suite.** Built-in CLI commands turn rustdl into
@@ -150,6 +153,7 @@ license; no separate CLA.
 
 ## More
 
+- Latest benchmark snapshot: [`docs/perf-2026-06-27-bench-snapshot.md`](docs/perf-2026-06-27-bench-snapshot.md)
 - Reasoner comparison: [`docs/reasoner-comparison-2026-06-21.md`](docs/reasoner-comparison-2026-06-21.md)
 - Perf vs Konclude/HermiT: [`docs/perf-2026-06-08-konclude-vs-rustdl.md`](docs/perf-2026-06-08-konclude-vs-rustdl.md)
 - Completeness envelope: [`docs/fragment-completeness.md`](docs/fragment-completeness.md)

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-py/src/classify.rs

@@ -1,7 +1,7 @@
 //! `classify` / `classify_bytes` top-level functions + the
 //! `Classification` `PyO3` class that wraps `owl_dl_reasoner::Classification`.
 
-use owl_dl_reasoner::{Classification as RsClassification, classify as rs_classify};
+use owl_dl_reasoner::Classification as RsClassification;
 use pyo3::prelude::*;
 
 use crate::errors::reason_error_to_py;
@@ -51,7 +51,8 @@ impl PyClassification {
     /// True iff classification ran to completion — no pair hit the
     /// timeout. When `False`, the hierarchy may be missing real
     /// subsumptions (see `timed_out_pairs`); re-classify with
-    /// `per_pair_timeout_ms=0` for the complete (unbounded) result.
+    /// `per_pair_timeout_ms=0, global_deadline_ms=0` for the complete
+    /// (unbounded) result.
     #[getter]
     fn complete(&self) -> bool {
         self.inner.stats().timed_out_pairs == 0
@@ -94,46 +95,67 @@ impl PyClassification {
 /// Format auto-detected from the file extension
 /// (`.ofn` | `.owx` | `.owl` | `.rdf` | `.omn`).
 #[pyfunction]
-#[pyo3(signature = (path, *, per_pair_timeout_ms=1000, saturation_only=false))]
+#[pyo3(signature = (path, *, per_pair_timeout_ms=100, global_deadline_ms=60000, saturation_only=false))]
 pub(crate) fn classify(
     path: &str,
     per_pair_timeout_ms: Option<u64>,
+    global_deadline_ms: Option<u64>,
     saturation_only: bool,
 ) -> PyResult<PyClassification> {
     let ontology = load::load_path(path)?;
-    do_classify(&ontology, per_pair_timeout_ms, saturation_only)
+    do_classify(
+        &ontology,
+        per_pair_timeout_ms,
+        global_deadline_ms,
+        saturation_only,
+    )
 }
 
 /// `rustdl.classify_bytes(data, format="ofn")` — same but from bytes.
 /// `format` is one of `"ofn"`, `"owx"`, `"rdf-xml"`, `"omn"`.
 #[pyfunction]
-#[pyo3(signature = (data, *, format, per_pair_timeout_ms=1000, saturation_only=false))]
+#[pyo3(signature = (data, *, format, per_pair_timeout_ms=100, global_deadline_ms=60000, saturation_only=false))]
 pub(crate) fn classify_bytes(
     data: &[u8],
     format: &str,
     per_pair_timeout_ms: Option<u64>,
+    global_deadline_ms: Option<u64>,
     saturation_only: bool,
 ) -> PyResult<PyClassification> {
     let ontology = load::load_bytes(data, format)?;
-    do_classify(&ontology, per_pair_timeout_ms, saturation_only)
+    do_classify(
+        &ontology,
+        per_pair_timeout_ms,
+        global_deadline_ms,
+        saturation_only,
+    )
 }
 
 fn do_classify(
     ontology: &horned_owl::ontology::set::SetOntology<horned_owl::model::RcStr>,
     per_pair_timeout_ms: Option<u64>,
+    global_deadline_ms: Option<u64>,
     saturation_only: bool,
 ) -> PyResult<PyClassification> {
     use std::time::Duration;
-    // `None` or `0` → unbounded (complete); any positive value bounds
-    // each pair (sound under-approximation; check `.complete` after).
-    let bounded = per_pair_timeout_ms.filter(|&ms| ms > 0);
+    // Two independent bounds (`0`/`None` disables that one): `per_pair`
+    // bounds any single `sub ⊓ ¬sup` pair; the global wall-budget bounds the
+    // TOTAL run so it can't grow with the pair count (the backstop against
+    // wine-class hangs). Each probe is cut at min(per_pair, remaining global).
+    // Cutting is a SOUND under-approximation — no false subsumptions; real
+    // ones may be missing (check `.complete` / `.timed_out_pairs`). Both
+    // disabled ⇒ unbounded/complete.
+    let per_pair = per_pair_timeout_ms
+        .filter(|&ms| ms > 0)
+        .map(Duration::from_millis);
+    let global = global_deadline_ms
+        .filter(|&ms| ms > 0)
+        .map(Duration::from_millis);
     let inner = if saturation_only {
         owl_dl_reasoner::classify_saturation_only(ontology).map_err(reason_error_to_py)?
-    } else if let Some(ms) = bounded {
-        owl_dl_reasoner::classify_top_down_with_timeout(ontology, Duration::from_millis(ms))
-            .map_err(reason_error_to_py)?
     } else {
-        rs_classify(ontology).map_err(reason_error_to_py)?
+        owl_dl_reasoner::classify_with_budget(ontology, per_pair, global)
+            .map_err(reason_error_to_py)?
     };
     Ok(PyClassification { inner })
 }

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-reasoner/README.md

@@ -6,7 +6,7 @@ consequence-based **saturation** engine handles the EL-ish fragment, a
 orchestrator picks per query. Parsing and the OWL model come from
 [`horned-owl`](https://github.com/phillord/horned-owl).
 
-## Status (v0.3.12)
+## Status (v0.3.16)
 
 A working classifier, consistency checker, and instance reasoner for SROIQ(D)
 with first-class data properties. The defining property is **soundness**: every
@@ -17,10 +17,13 @@ reported subsumption is a genuine entailment.
   nothing that neither complete reasoner does.
 - **Fastest on EL.** rustdl's saturation kernel beats whelk-rs (1.4–1.9×) and ELK
   (4.5×) on galen/notgalen, deriving a sound *superset* of their closures.
-- **Competitive on DL, not the speed leader.** After recent work, most DL
-  ontologies classify within ~10–50× of Konclude (the mature C++ tableau, which
-  wins on speed); HermiT is slower still and itself DNFs on a hard tail.
-  **wine** is rustdl's one DNF (combinatorial nominal+disjunction).
+- **Competitive on DL, not the speed leader.** Most DL ontologies classify
+  within ~10–50× of Konclude (the mature C++ tableau, which wins on speed);
+  HermiT is slower still and itself DNFs on a hard tail. **wine — once rustdl's
+  one DNF (combinatorial nominal+disjunction) — now classifies soundly in ~1.6 s**
+  (a ~30× reduction from the coupled-saturation ∃-seed plus wedge search-ordering
+  work; see the [v0.3.16 snapshot](docs/perf-2026-06-27-bench-snapshot.md)). A
+  residual of ~9 idiosyncratic ORE-pilot ontologies stays hard.
 - Detects the **family** inconsistency (a consequence-based ABox-saturation
   pre-check) that the per-pair tableau alone misses.
 - **Explains *and* debugs — a full suite.** Built-in CLI commands turn rustdl into
@@ -150,6 +153,7 @@ license; no separate CLA.
 
 ## More
 
+- Latest benchmark snapshot: [`docs/perf-2026-06-27-bench-snapshot.md`](docs/perf-2026-06-27-bench-snapshot.md)
 - Reasoner comparison: [`docs/reasoner-comparison-2026-06-21.md`](docs/reasoner-comparison-2026-06-21.md)
 - Perf vs Konclude/HermiT: [`docs/perf-2026-06-08-konclude-vs-rustdl.md`](docs/perf-2026-06-08-konclude-vs-rustdl.md)
 - Completeness envelope: [`docs/fragment-completeness.md`](docs/fragment-completeness.md)

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-reasoner/src/abox_saturation.rs

@@ -318,6 +318,17 @@ pub fn saturate_abox_consistency(internal: &InternalOntology) -> SaturationResul
                     }
                 }
             }
+            Axiom::TransitiveRole(r) => {
+                // Transitivity is the self-chain `R ∘ R ⊑ R`; registering it as a
+                // length-2 chain lets the Rule-4 fixpoint close the full transitive
+                // closure of `R`-edges — jointly with the role hierarchy, inverse
+                // materialization, and declared chains (a transitive edge can feed
+                // a sub-property/chain rule and vice-versa). The inverse of a
+                // transitive role is transitive too, and is covered by inverse
+                // materialization re-running over the closed forward edges.
+                let k = role_key(*r);
+                chains2.push((k, k, k));
+            }
             Axiom::ObjectPropertyDomain { role, domain } => {
                 if let Some(d) = atomic_class(*domain) {
                     domains.entry(role_key(*role)).or_default().push(d);

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-reasoner/src/classify.rs

@@ -438,6 +438,30 @@ pub fn classify_with_global_deadline<A: ForIRI>(
     classify_top_down_internal(&internal, None, Some(deadline))
 }
 
+/// Classify with BOTH a per-pair tableau deadline and a global wall-clock
+/// budget — the recommended bounded entry point. Each probe is cut at
+/// `min(per_pair, remaining global)` (see [`effective_deadline`]); `per_pair`
+/// bounds any single pair, `global_budget` bounds the total wall so the run
+/// can't grow with the pair count. Either may be `None` (that bound absent;
+/// both `None` ⇒ the unbounded top-down classify).
+///
+/// **Sound** at every setting: a cut probe defaults to "not subsumed"
+/// (FP=0; the hierarchy may MISS a real subsumption — inspect
+/// [`ClassificationStats`]`::complete` / `timed_out_pairs`).
+///
+/// # Errors
+///
+/// See [`ReasonError`].
+pub fn classify_with_budget<A: ForIRI>(
+    ontology: &SetOntology<A>,
+    per_pair_timeout: Option<std::time::Duration>,
+    global_budget: Option<std::time::Duration>,
+) -> Result<Classification, ReasonError> {
+    let internal = convert_ontology(ontology)?;
+    let global_deadline = global_budget.map(|b| Instant::now() + b);
+    classify_top_down_internal(&internal, per_pair_timeout, global_deadline)
+}
+
 /// Naive `n²` pair-sweep classifier. Kept for benchmarking and
 /// regression cross-checks against [`classify`]. On real workloads
 /// it is consistently 2× slower than the default top-down path; new

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-reasoner/src/lib.rs

@@ -54,8 +54,8 @@ mod union_find;
 pub use classify::{
     Classification, ClassificationStats, FragmentClassification, analyze_fragment, classify,
     classify_internal, classify_n2, classify_n2_with_timeout, classify_saturation_only,
-    classify_top_down, classify_top_down_with_timeout, classify_with_global_deadline,
-    classify_with_timeout,
+    classify_top_down, classify_top_down_with_timeout, classify_with_budget,
+    classify_with_global_deadline, classify_with_timeout,
 };
 pub use diagnose::{DerivedClass, Diagnosis, diagnose};
 pub use laconic::{find_all_laconic_justifications, find_laconic_justification};

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-reasoner/tests/property_assertions.rs

@@ -51,6 +51,81 @@ fn subproperty_entailed_assertions() {
     assert!(!got.contains(&triple("urn:a", "urn:hasAncestor", "urn:a")));
 }
 
+/// Issue #26: a `TransitiveObjectProperty` must materialize the full transitive
+/// closure of its asserted edges, not just the one-step edges.
+#[test]
+fn transitive_closure_materialized() {
+    let b = Build::new_rc();
+    let mut o = SetOntology::new();
+    o.insert(DeclareObjectProperty(b.object_property("urn:ancestorOf")));
+    o.insert(horned_owl::model::TransitiveObjectProperty(
+        ObjectPropertyExpression::ObjectProperty(b.object_property("urn:ancestorOf")),
+    ));
+    for i in ["urn:a", "urn:b", "urn:c", "urn:d"] {
+        o.insert(horned_owl::model::DeclareNamedIndividual(
+            b.named_individual(i),
+        ));
+    }
+    o.insert(opa(&b, "urn:ancestorOf", "urn:a", "urn:b"));
+    o.insert(opa(&b, "urn:ancestorOf", "urn:b", "urn:c"));
+    o.insert(opa(&b, "urn:ancestorOf", "urn:c", "urn:d"));
+
+    let got = materialize_object_property_assertions(&o).expect("materialize");
+    let t = |s: &str, x: &str| (s.to_string(), "urn:ancestorOf".to_string(), x.to_string());
+    // one-step (already worked)
+    assert!(got.contains(&t("urn:a", "urn:b")), "got: {got:?}");
+    assert!(got.contains(&t("urn:b", "urn:c")), "got: {got:?}");
+    assert!(got.contains(&t("urn:c", "urn:d")), "got: {got:?}");
+    // transitive closure (the regression)
+    assert!(got.contains(&t("urn:a", "urn:c")), "a⊑c missing: {got:?}");
+    assert!(got.contains(&t("urn:b", "urn:d")), "b⊑d missing: {got:?}");
+    assert!(got.contains(&t("urn:a", "urn:d")), "a⊑d missing: {got:?}");
+}
+
+/// Issue #26 larger case: sub-property + inverse + transitivity compose, so the
+/// transitive edge through the sub-property/inverse rewrites is materialized.
+#[test]
+fn transitive_with_subproperty_and_inverse() {
+    let b = Build::new_rc();
+    let mut o = SetOntology::new();
+    for p in ["urn:hasParent", "urn:hasChild", "urn:hasAncestor"] {
+        o.insert(DeclareObjectProperty(b.object_property(p)));
+    }
+    for i in ["urn:alice", "urn:mary", "urn:john"] {
+        o.insert(horned_owl::model::DeclareNamedIndividual(
+            b.named_individual(i),
+        ));
+    }
+    // hasParent ⊑ hasAncestor ; hasAncestor transitive ; hasChild ≡ hasParent⁻
+    o.insert(SubObjectPropertyOf {
+        sub: SubObjectPropertyExpression::ObjectPropertyExpression(
+            ObjectPropertyExpression::ObjectProperty(b.object_property("urn:hasParent")),
+        ),
+        sup: ObjectPropertyExpression::ObjectProperty(b.object_property("urn:hasAncestor")),
+    });
+    o.insert(horned_owl::model::TransitiveObjectProperty(
+        ObjectPropertyExpression::ObjectProperty(b.object_property("urn:hasAncestor")),
+    ));
+    o.insert(horned_owl::model::InverseObjectProperties(
+        b.object_property("urn:hasChild"),
+        b.object_property("urn:hasParent"),
+    ));
+    o.insert(opa(&b, "urn:hasChild", "urn:mary", "urn:alice")); // mary hasChild alice
+    o.insert(opa(&b, "urn:hasParent", "urn:mary", "urn:john")); // mary hasParent john
+
+    let got = materialize_object_property_assertions(&o).expect("materialize");
+    let anc = |s: &str, x: &str| (s.to_string(), "urn:hasAncestor".to_string(), x.to_string());
+    // alice hasParent mary (inverse) ⟹ alice hasAncestor mary (sub-property)
+    assert!(got.contains(&anc("urn:alice", "urn:mary")), "got: {got:?}");
+    // mary hasAncestor john (sub-property)
+    assert!(got.contains(&anc("urn:mary", "urn:john")), "got: {got:?}");
+    // the composed edge (the regression): alice hasAncestor john
+    assert!(
+        got.contains(&anc("urn:alice", "urn:john")),
+        "composed alice⊑john missing: {got:?}"
+    );
+}
+
 use owl_dl_reasoner::justify::{Entailment, entails};
 
 #[test]

{rustdl-0.3.16 → rustdl-0.3.18}/crates/owl-dl-saturation/README.md

@@ -6,7 +6,7 @@ consequence-based **saturation** engine handles the EL-ish fragment, a
 orchestrator picks per query. Parsing and the OWL model come from
 [`horned-owl`](https://github.com/phillord/horned-owl).
 
-## Status (v0.3.12)
+## Status (v0.3.16)
 
 A working classifier, consistency checker, and instance reasoner for SROIQ(D)
 with first-class data properties. The defining property is **soundness**: every
@@ -17,10 +17,13 @@ reported subsumption is a genuine entailment.
   nothing that neither complete reasoner does.
 - **Fastest on EL.** rustdl's saturation kernel beats whelk-rs (1.4–1.9×) and ELK
   (4.5×) on galen/notgalen, deriving a sound *superset* of their closures.
-- **Competitive on DL, not the speed leader.** After recent work, most DL
-  ontologies classify within ~10–50× of Konclude (the mature C++ tableau, which
-  wins on speed); HermiT is slower still and itself DNFs on a hard tail.
-  **wine** is rustdl's one DNF (combinatorial nominal+disjunction).
+- **Competitive on DL, not the speed leader.** Most DL ontologies classify
+  within ~10–50× of Konclude (the mature C++ tableau, which wins on speed);
+  HermiT is slower still and itself DNFs on a hard tail. **wine — once rustdl's
+  one DNF (combinatorial nominal+disjunction) — now classifies soundly in ~1.6 s**
+  (a ~30× reduction from the coupled-saturation ∃-seed plus wedge search-ordering
+  work; see the [v0.3.16 snapshot](docs/perf-2026-06-27-bench-snapshot.md)). A
+  residual of ~9 idiosyncratic ORE-pilot ontologies stays hard.
 - Detects the **family** inconsistency (a consequence-based ABox-saturation
   pre-check) that the per-pair tableau alone misses.
 - **Explains *and* debugs — a full suite.** Built-in CLI commands turn rustdl into
@@ -150,6 +153,7 @@ license; no separate CLA.
 
 ## More
 
+- Latest benchmark snapshot: [`docs/perf-2026-06-27-bench-snapshot.md`](docs/perf-2026-06-27-bench-snapshot.md)
 - Reasoner comparison: [`docs/reasoner-comparison-2026-06-21.md`](docs/reasoner-comparison-2026-06-21.md)
 - Perf vs Konclude/HermiT: [`docs/perf-2026-06-08-konclude-vs-rustdl.md`](docs/perf-2026-06-08-konclude-vs-rustdl.md)
 - Completeness envelope: [`docs/fragment-completeness.md`](docs/fragment-completeness.md)

rustdl-0.3.18/crates/owl-dl-tableau/README.md

@@ -0,0 +1,161 @@
+# rustdl
+
+A **sound** OWL 2 DL (SROIQ) reasoner in Rust. Konclude-style hybrid: a
+consequence-based **saturation** engine handles the EL-ish fragment, a
+**tableau** + hypertableau **wedge** handles the rest of SROIQ, and an
+orchestrator picks per query. Parsing and the OWL model come from
+[`horned-owl`](https://github.com/phillord/horned-owl).
+
+## Status (v0.3.16)
+
+A working classifier, consistency checker, and instance reasoner for SROIQ(D)
+with first-class data properties. The defining property is **soundness**: every
+reported subsumption is a genuine entailment.
+
+- **FP = 0 at scale.** Verified against the Konclude ∩ HermiT oracle across all
+  201 diffed ORE-2015 pilot ontologies *and* the curated corpus — rustdl asserts
+  nothing that neither complete reasoner does.
+- **Fastest on EL.** rustdl's saturation kernel beats whelk-rs (1.4–1.9×) and ELK
+  (4.5×) on galen/notgalen, deriving a sound *superset* of their closures.
+- **Competitive on DL, not the speed leader.** Most DL ontologies classify
+  within ~10–50× of Konclude (the mature C++ tableau, which wins on speed);
+  HermiT is slower still and itself DNFs on a hard tail. **wine — once rustdl's
+  one DNF (combinatorial nominal+disjunction) — now classifies soundly in ~1.6 s**
+  (a ~30× reduction from the coupled-saturation ∃-seed plus wedge search-ordering
+  work; see the [v0.3.16 snapshot](docs/perf-2026-06-27-bench-snapshot.md)). A
+  residual of ~9 idiosyncratic ORE-pilot ontologies stays hard.
+- Detects the **family** inconsistency (a consequence-based ABox-saturation
+  pre-check) that the per-pair tableau alone misses.
+- **Explains *and* debugs — a full suite.** Built-in CLI commands turn rustdl into
+  an ontology-debugging tool, not just a classifier:
+  - `justify` — a minimal responsible-axiom set for any entailment (`--laconic`
+    weakens each axiom to its responsible *fragment*).
+  - `prove` — a step-level proof tree.
+  - `diagnose` — partitions unsatisfiable classes into **root** causes vs **derived**
+    collateral ("where to start fixing").
+  - `repair` — minimal axiom-removal sets to *break* an unwanted entailment, each
+    verified.
+  - `report` — a self-contained HTML debugging report combining all of the above.
+
+  Every result is **sound by construction** (justifications and repairs are verified
+  against the reasoner). **Konclude** (the DL speed leader) has **no built-in
+  justification or explanation facility** at all (its interface is classification /
+  consistency / realization / SPARQL only) — so the fastest reasoner tells you *that*
+  a subsumption holds but not *why*, or *how to fix* a broken ontology. rustdl does.
+
+Full head-to-head (5 reasoners × 2 corpora):
+[`docs/reasoner-comparison-2026-06-21.md`](docs/reasoner-comparison-2026-06-21.md).
+
+**Completeness is partial** — the default classifier is empirically near-complete
+across the measured corpus but not *provably* complete in general (it trusts the
+wedge's `Sat` verdicts; see the soundness contract in `CLAUDE.md` and
+[`docs/fragment-completeness.md`](docs/fragment-completeness.md)). The hard residual
+is the engineering-maturity gap to Konclude's optimized tableau, not a missing
+technique.
+
+## Coverage
+
+**Supported (sound; complete on the fragment, oracle-validated):**
+
+- SROIQ object-property reasoning — role hierarchies; transitive, symmetric,
+  asymmetric, irreflexive, functional, inverse-functional; inverse roles; role
+  chains (longer chains decomposed to 2-leg cascades).
+- Class expressions — intersection, union, complement, nominals (`{a}`),
+  existential / universal restrictions, qualified cardinality (`≥n R.C`, `≤n R.C`).
+- `DisjointClasses`, `EquivalentClasses`, `DisjointUnion`.
+- ABox — `ClassAssertion`, `ObjectPropertyAssertion`,
+  `NegativeObjectPropertyAssertion`, `SameIndividual`, `DifferentIndividuals`;
+  consistency via an ABox-saturation pre-check + clash-pattern checks.
+- **Data properties are first-class** (default-on) — data-property axioms lower to
+  the object fragment; concrete domains cover integer / float / decimal / date /
+  dateTime / string value-membership, faceted ranges, `DataOneOf`, and bounded
+  data cardinality.
+
+**Sound under-approximation (silently dropped, never an error):** data ranges /
+nested composites outside the recognized set; positives depending on them may be
+missed, never falsely asserted.
+
+**Unsupported (errors):** `HasKey`. SWRL rules are skipped (see `convert.rs`).
+
+## Crates
+
+`owl-dl-core` (IR + normalization), `owl-dl-saturation` (EL closure),
+`owl-dl-tableau` (SROIQ tableau + hypertableau wedge), `owl-dl-datatypes`
+(concrete domains), `owl-dl-reasoner` (orchestrator + public API), `owl-dl-cli`
+(`rustdl` binary), `owl-dl-bench` (corpus/benchmark harness), `owl-dl-py` (Python
+bindings). `xtask` holds build automation.
+
+## Install
+
+```sh
+cargo add owl-dl-reasoner                                              # library
+cargo install --git https://github.com/MaastrichtU-IDS/rustdl owl-dl-cli   # CLI
+pip install rustdl                                                     # Python 3.10+ (ABI3)
+```
+
+```python
+import rustdl
+result = rustdl.classify("ontology.ofn")   # OFN / OWX / RDF-XML / Manchester (.omn) — auto-detected
+print(f"{len(result.classes)} classes; {len(result.unsatisfiable)} unsat")
+print(result.is_subclass("http://ex.org/Sub", "http://ex.org/Sup"))
+ok = rustdl.is_consistent("ontology.ofn")
+edges = rustdl.materialize_inferred_property_assertions("ontology.ofn")  # inferred object property assertions
+data_edges = rustdl.materialize_inferred_data_property_assertions("ontology.ofn")  # inferred data property assertions
+sub_obj = rustdl.materialize_inferred_subobjectproperty_axioms("ontology.ofn")  # object property hierarchy
+sub_dat = rustdl.materialize_inferred_subdataproperty_axioms("ontology.ofn")    # data property hierarchy
+succ = rustdl.materialize_existential_successors("ontology.ofn")  # entailed exists-successors (blank-node witnesses)
+report = rustdl.debug("ontology.ofn")   # consistency + root/derived unsat + justifications + repairs
+```
+
+New to the Python API? Walk through
+[**Debugging an ontology with rustdl**](docs/python-ontology-qa.md) — an end-to-end
+QA tutorial (classify → `debug()` → justify/repair → fix → read inferred facts).
+
+## Build & test
+
+```sh
+cargo build --workspace --release     # Rust 1.88+, edition 2024
+cargo fmt --all -- --check
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+cargo test --workspace
+```
+
+## CLI
+
+```sh
+rustdl classify  ontology.ofn               # full class hierarchy (default)
+rustdl consistent ontology.ofn
+rustdl subclass  ontology.ofn <sub> <sup>
+rustdl instances ontology.ofn <class>
+rustdl realize   ontology.ofn [--properties] # per-individual types (+ inferred object & data property assertions)
+rustdl justify   ontology.ofn <query…>      # minimal responsible-axiom set (why it holds)
+rustdl justify --laconic ontology.ofn <query…>  # pinpoint the responsible PART of each axiom
+rustdl repair    ontology.ofn <query…>      # minimal axiom removals to break an entailment
+rustdl prove     ontology.ofn <sub> <sup>   # step-level DL proof tree
+rustdl diagnose  ontology.ofn               # root vs derived unsatisfiable classes (where to start fixing)
+rustdl report    ontology.ofn -o report.html # self-contained HTML debugging report
+rustdl explain   ontology.ofn <sub> <sup>   # which engine answered (saturation vs tableau)
+```
+
+Sound under-approximation modes (every reported subsumption still holds; positives
+may be missed): `--saturation-only` (skip the tableau, EL-closure only) and
+`--pair-timeout-ms N` (per-pair tableau deadline; cut pairs default to "not
+subsumed" — robust on pathological SROIQ inputs). Diagnostics: `RUSTDL_TRACE=1`
+(one stderr line per search/branch decision); `RUSTDL_COUNTERS=1` with
+`--features counters` (per-rule call counts).
+
+## Licensing
+
+Dual-licensed [Apache-2.0](LICENSE-APACHE) **OR** [MIT](LICENSE-MIT). `horned-owl`
+is LGPL-3.0; binaries that statically link it inherit LGPL-3.0 obligations for that
+portion (see [`NOTICE`](NOTICE)). Contributions are accepted under the same dual
+license; no separate CLA.
+
+## More
+
+- Latest benchmark snapshot: [`docs/perf-2026-06-27-bench-snapshot.md`](docs/perf-2026-06-27-bench-snapshot.md)
+- Reasoner comparison: [`docs/reasoner-comparison-2026-06-21.md`](docs/reasoner-comparison-2026-06-21.md)
+- Perf vs Konclude/HermiT: [`docs/perf-2026-06-08-konclude-vs-rustdl.md`](docs/perf-2026-06-08-konclude-vs-rustdl.md)
+- Completeness envelope: [`docs/fragment-completeness.md`](docs/fragment-completeness.md)
+- Strategy: [`docs/owl-dl-reasoner-rust-strategy-v2.md`](docs/owl-dl-reasoner-rust-strategy-v2.md)
+- Engineering notes & soundness contract: [`CLAUDE.md`](CLAUDE.md)