rustdl 0.3.4__tar.gz → 0.3.6__tar.gz

{rustdl-0.3.4 → rustdl-0.3.6}/Cargo.lock

@@ -1037,7 +1037,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "anyhow",
  "clap",
@@ -1054,7 +1054,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "anyhow",
  "clap",
@@ -1066,7 +1066,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1080,7 +1080,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1090,7 +1090,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1101,7 +1101,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "dashmap",
  "horned-owl",
@@ -1117,7 +1117,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1133,7 +1133,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2569,7 +2569,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.3.4"
+version = "0.3.6"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.3.4 → rustdl-0.3.6}/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.4"
+version = "0.3.6"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0 OR MIT"
@@ -15,11 +15,11 @@ keywords = ["owl", "ontology", "reasoner", "description-logic", "semantic-web"]
 categories = ["science", "data-structures"]
 
 [workspace.dependencies]
-owl-dl-core = { path = "crates/owl-dl-core", version = "0.3.4" }
-owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.4" }
-owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.4" }
-owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.4" }
-owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.4" }
+owl-dl-core = { path = "crates/owl-dl-core", version = "0.3.6" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.6" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.6" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.6" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.6" }
 
 horned-owl = { version = "1.4", default-features = false }
 

{rustdl-0.3.4 → rustdl-0.3.6}/PKG-INFO

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

{rustdl-0.3.4 → rustdl-0.3.6}/crates/owl-dl-reasoner/src/classify.rs

@@ -138,6 +138,10 @@ pub struct ClassificationStats {
     /// entailment matrix — sound (never reports a false positive),
     /// but may under-report subsumption.
     pub timed_out_pairs: usize,
+    /// Subsumptions recovered by the defined-SUB sweep: a union-defined
+    /// `C ≡ D₁ ⊔ … ⊔ Dₙ` ⊑ a primitive sup `X` where every `Dᵢ ⊑ X` holds
+    /// in the EL closure (sound by construction). Added directly, no tableau.
+    pub defined_sub_sweep_recovered: usize,
     /// Pairs proved subsumed by the H4 hypertableau wedge (sound
     /// `Unsat`), skipping the tableau. Zero unless the wedge is
     /// enabled (`RUSTDL_HYPERTABLEAU`).
@@ -1262,6 +1266,84 @@ pub(crate) fn classify_top_down_internal(
         }
     }
 
+    // Defined-SUB sweep (cluster A; wine residual-31, 2026-06-07). The
+    // defined-sup sweep above only tests pairs whose SUP is a defined class.
+    // A union/covering-defined SUB `C ≡ D₁ ⊔ … ⊔ Dₙ` ⊑ a *primitive* sup X
+    // (e.g. `Fruit ≡ NonSweetFruit ⊔ SweetFruit ⊑ EdibleThing`, where
+    // `EdibleThing` is `SubClassOf`-only) is missed by BOTH the tier-walk (the
+    // covering subsumption isn't in the EL closure) AND the defined-sup sweep
+    // (X is primitive). Recover it soundly *by construction*: if the sound EL
+    // closure has `Dᵢ ⊑ X` for EVERY disjunct, then `C ⊑ ⊔Dᵢ ⊑ X`. So the
+    // candidate sups are exactly the common closure-supersumers of the
+    // disjuncts (`∩ᵢ subsumers(Dᵢ)`); each is a genuine entailment — added
+    // directly, no tableau/wedge call (hence no per-pair-budget timeout risk).
+    // See docs/classify-recovery-scope-2026-06-07.md.
+    for ax in &internal.axioms {
+        let owl_dl_core::ontology::Axiom::EquivalentClasses(ids) = ax else {
+            continue;
+        };
+        // Identify the named class `C` (an Atomic operand) and a union
+        // operand whose disjuncts are all atomic.
+        let mut name: Option<usize> = None;
+        let mut disjuncts: Option<Vec<usize>> = None;
+        for cid in ids {
+            match internal.concepts.get(*cid) {
+                owl_dl_core::ir::ConceptExpr::Atomic(cls) => name = Some(cls.index() as usize),
+                owl_dl_core::ir::ConceptExpr::Or(ds) => {
+                    let atoms: Option<Vec<usize>> = ds
+                        .iter()
+                        .map(|d| match internal.concepts.get(*d) {
+                            owl_dl_core::ir::ConceptExpr::Atomic(dc) => Some(dc.index() as usize),
+                            _ => None,
+                        })
+                        .collect();
+                    if let Some(a) = atoms {
+                        disjuncts = Some(a);
+                    }
+                }
+                _ => {}
+            }
+        }
+        let (Some(c), Some(ds)) = (name, disjuncts) else {
+            continue;
+        };
+        if c >= n || ds.is_empty() || unsatisfiable_idxs.contains(&c) {
+            continue;
+        }
+        // Candidate sups = intersection of the disjuncts' closure-subsumers.
+        let mut cand: Option<std::collections::HashSet<usize>> = None;
+        for &d in &ds {
+            let d_id =
+                owl_dl_core::ClassId::new(u32::try_from(d).expect("class index fits in u32"));
+            let subs: std::collections::HashSet<usize> = closure
+                .subsumers_of(d_id)
+                .into_iter()
+                .map(|s| s.index() as usize)
+                .filter(|&j| j < n)
+                .collect();
+            cand = Some(match cand {
+                None => subs,
+                Some(prev) => prev.intersection(&subs).copied().collect(),
+            });
+        }
+        let c_id = owl_dl_core::ClassId::new(u32::try_from(c).expect("class index fits in u32"));
+        for x in cand.unwrap_or_default() {
+            if x == c || unsatisfiable_idxs.contains(&x) {
+                continue;
+            }
+            let x_id =
+                owl_dl_core::ClassId::new(u32::try_from(x).expect("class index fits in u32"));
+            // Skip subsumptions already on `C`'s closure ray (the entailment
+            // matrix seeds those) or already recorded.
+            if closure.contains(c_id, x_id) || direct_supers[c].contains(&x) {
+                continue;
+            }
+            stats.defined_sub_sweep_recovered += 1;
+            direct_supers[c].push(x);
+            direct_children[x].push(c);
+        }
+    }
+
     // Build the full entailment matrix. Three sources contribute:
     //
     // 1. **Closure seed.** Every saturation-derived subsumption is
@@ -1625,6 +1707,122 @@ mod tests {
         ontology
     }
 
+    /// Diagnostic probe (wine residual-31, cluster A): why does classify miss
+    /// `food#Fruit ⊑ food#EdibleThing` when `is_subclass_of` proves it in 0.01s?
+    /// Compares the fresh tableau (`is_subclass_of_internal`) against the
+    /// classify-path `PreparedOntology::decide` (the ABox-seeded snapshot) on the
+    /// exact query `Fruit ⊓ ¬EdibleThing`, unbounded and at the 200ms classify
+    /// budget. Settles timeout-vs-wrong-verdict. See
+    /// `docs/wine-residual-31-diagnosis-2026-06-07.md`. `#[ignore]`d (needs the
+    /// gitignored wine fixture); run with `-- --ignored --nocapture`.
+    #[test]
+    #[ignore = "needs ontologies/real/wine.ofn; diagnostic for the Fruit cluster-A classify miss"]
+    fn wine_fruit_prepared_vs_fresh_probe() {
+        use horned_owl::io::ofn::reader::read as read_ofn;
+        let path = std::path::Path::new("../../ontologies/real/wine.ofn");
+        if !path.exists() {
+            eprintln!("SKIP: missing {}", path.display());
+            return;
+        }
+        let f = "http://www.w3.org/TR/2003/PR-owl-guide-20031209/food#Fruit";
+        let e = "http://www.w3.org/TR/2003/PR-owl-guide-20031209/food#EdibleThing";
+        let src = std::fs::read_to_string(path).expect("read wine");
+        let parse_onto = || {
+            let mut r = Cursor::new(src.clone());
+            let (o, _): (SetOntology<RcStr>, _) =
+                read_ofn(&mut r, ParserConfiguration::default()).expect("parse wine");
+            o
+        };
+
+        // Fresh path (what subclass / explain use).
+        let fresh = crate::is_subclass_of(&parse_onto(), f, e).expect("fresh is_subclass_of");
+        eprintln!("FRESH is_subclass_of(Fruit, EdibleThing) = {fresh}");
+
+        // Classify-path: PreparedOntology::decide on `Fruit ⊓ ¬EdibleThing`.
+        let internal = owl_dl_core::convert::convert_ontology(&parse_onto()).expect("convert");
+        let cons = "http://www.w3.org/TR/2003/PR-owl-guide-20031209/food#ConsumableThing";
+        let fid = internal.vocabulary.class_id(f).expect("Fruit id");
+        let eid = internal.vocabulary.class_id(e).expect("EdibleThing id");
+        let cid = internal
+            .vocabulary
+            .class_id(cons)
+            .expect("ConsumableThing id");
+        // EL closure witness?
+        let closure = owl_dl_saturation::saturate(&internal);
+        eprintln!(
+            "CLOSURE.contains(Fruit, EdibleThing) = {}",
+            closure.contains(fid, eid)
+        );
+        let prepared = PreparedOntology::from_internal(internal).expect("prepare");
+        // The classify walk tries the WEDGE first (hyper_decide), only falling
+        // to the tableau on a non-proof. Measure both deadlines.
+        let tw = std::time::Instant::now();
+        let wedge_unbounded = prepared.hyper_decide(fid, eid, None);
+        eprintln!(
+            "WEDGE prepared.hyper_decide(None) = {wedge_unbounded:?} in {} ms",
+            tw.elapsed().as_millis()
+        );
+        let tw2 = std::time::Instant::now();
+        let wdl = std::time::Instant::now() + std::time::Duration::from_millis(200);
+        let wedge_200 = prepared.hyper_decide(fid, eid, Some(wdl));
+        eprintln!(
+            "WEDGE prepared.hyper_decide(Fruit,EdibleThing,200ms) = {wedge_200:?} in {} ms",
+            tw2.elapsed().as_millis()
+        );
+        // The descent GATE: EdibleThing ⊑ ConsumableThing (top-level), so the
+        // walk reaches EdibleThing only by first accepting ConsumableThing.
+        let tc = std::time::Instant::now();
+        let cdl = std::time::Instant::now() + std::time::Duration::from_millis(200);
+        let wedge_cons = prepared.hyper_decide(fid, cid, Some(cdl));
+        eprintln!(
+            "WEDGE prepared.hyper_decide(Fruit,ConsumableThing,200ms) = {wedge_cons:?} in {} ms  [descent gate]",
+            tc.elapsed().as_millis()
+        );
+        // SEPARATE finding (NOT cluster A's cause — the WEDGE proves Fruit ⊑
+        // EdibleThing in 0 ms above, so the tableau is never reached for this
+        // pair in classify). The ABox/nominal-seeded `prepared.decide` is
+        // pathologically slow / non-terminating: a 5 s deadline times out, vs the
+        // fresh path's 0.01 s (unbounded does not return in 150 s — do NOT call
+        // it). This matters for the B/C/D pairs (whose wedge does NOT prove them
+        // → tableau fallback). Cluster A's actual cause is the defined-sup sweep
+        // coverage gap; see docs/classify-recovery-scope-2026-06-07.md.
+        let build = |pool: &mut owl_dl_core::ir::ConceptPool| {
+            let fc = pool.atomic(fid);
+            let ec = pool.atomic(eid);
+            let nec = pool.not(ec);
+            pool.and(vec![fc, nec])
+        };
+        let t0 = std::time::Instant::now();
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+        let bounded = prepared
+            .decide_with_deadline(deadline, build)
+            .expect("prepared.decide_with_deadline");
+        let ms = t0.elapsed().as_millis();
+        eprintln!("PREPARED.decide_with_deadline(5s) = {bounded:?} (None=timeout) in {ms} ms");
+
+        eprintln!(
+            "VERDICT: {}",
+            match (fresh, bounded) {
+                (true, None) =>
+                    "wedge proves it in 0ms (cluster A = defined-sup-sweep gap); \
+                     SEPARATELY the ABox-seeded prepared.decide tableau times out even at 5s \
+                     (non-termination, affects B/C/D)",
+                (true, Some(false)) =>
+                    "prepared agrees (subsumed) within 5s ⇒ the miss is only the 200ms budget",
+                (true, Some(true)) =>
+                    "prepared returns WRONG Sat ⇒ PreparedOntology completeness bug",
+                _ => "fresh disagrees — re-examine",
+            }
+        );
+        // Pin the established finding: fresh proves it; prepared cannot in 5s.
+        assert!(fresh, "fresh is_subclass_of must prove Fruit ⊑ EdibleThing");
+        assert_eq!(
+            bounded, None,
+            "regression: prepared.decide now finishes in 5s — the ABox-seeding \
+             pathology may be fixed; update docs/wine-residual-31-diagnosis"
+        );
+    }
+
     const HEADER: &str = "\
 Prefix(:=<http://rustdl.test/>)\n\
 Prefix(owl:=<http://www.w3.org/2002/07/owl#>)\n";
@@ -1700,6 +1898,41 @@ Ontology(<http://rustdl.test/test>\n\
         assert_eq!(direct, vec![iri("B")]);
     }
 
+    /// Regression for the defined-SUB sweep (cluster A; wine residual-31,
+    /// 2026-06-07). A union/covering-defined sub `C ≡ A ⊔ B` ⊑ a PRIMITIVE sup
+    /// `X` (every disjunct `⊑ X`) is missed by both the tier-walk (the covering
+    /// subsumption isn't in the EL closure) and the defined-sup sweep (`X` is
+    /// primitive). The companion defined-SUB sweep recovers it soundly by
+    /// construction. Mirrors wine's `Fruit ≡ NonSweetFruit ⊔ SweetFruit ⊑
+    /// EdibleThing`. See docs/classify-recovery-scope-2026-06-07.md.
+    #[test]
+    fn defined_union_sub_under_primitive_sup() {
+        let onto = parse(&format!(
+            "{HEADER}\
+Ontology(<http://rustdl.test/test>\n\
+    Declaration(Class(:C))\n\
+    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    Declaration(Class(:X))\n\
+    EquivalentClasses(:C ObjectUnionOf(:A :B))\n\
+    SubClassOf(:A :X)\n\
+    SubClassOf(:B :X)\n\
+)\n"
+        ));
+        let h = classify(&onto).expect("classification");
+        let iri = |s: &str| format!("http://rustdl.test/{s}");
+        // C ≡ A ⊔ B, A ⊑ X, B ⊑ X ⟹ C ⊑ X (every model element of C is in
+        // A or B, both ⊑ X). `X` is primitive, so only the defined-SUB sweep
+        // recovers this.
+        assert!(
+            h.is_subclass(&iri("C"), &iri("X")),
+            "defined-SUB sweep must place C ⊑ X"
+        );
+        // Disjuncts and the union are mutually subsumed by X but not vice versa.
+        assert!(h.is_subclass(&iri("A"), &iri("X")));
+        assert!(!h.is_subclass(&iri("X"), &iri("C")));
+    }
+
     #[test]
     fn classify_groups_equivalents() {
         // EquivalentClasses(A, B) — they should appear as each

{rustdl-0.3.4 → rustdl-0.3.6}/crates/owl-dl-reasoner/src/lib.rs

@@ -577,6 +577,9 @@ pub fn hyper_subsumption_probe<A: horned_owl::model::ForIRI>(
             if hyper_double_block_enabled() {
                 engine = engine.with_double_blocking();
             }
+            if hyper_precise_card_deps_enabled() {
+                engine = engine.with_precise_card_deps();
+            }
             let result = engine.decide_with_deadline(max_depth, deadline);
             let stats = engine.stats();
             let wall_ms = start.elapsed().as_secs_f64() * 1000.0;
@@ -637,6 +640,23 @@ pub fn hyper_double_block_enabled() -> bool {
     std::env::var_os("RUSTDL_HYPER_DOUBLE_BLOCK").is_none_or(|v| v != "0" && !v.is_empty())
 }
 
+/// Precise (sound over-approx) `≤n`-cardinality clash deps
+/// (`RUSTDL_PRECISE_CARD_DEPS`). At the `forced_distinct_exceeds` pre-check site
+/// replaces the conservative `DepSet::ALL` with `parent.at_most_dep ∪ ⋃(birth ∪
+/// label of succs) ∪ parent(birth ∪ label)` — a provable superset of the clash's
+/// true deps (sound by construction; see `card_clash_deps`), guarded by the
+/// own-successor / `≠`-only / merge-taint fallbacks. Unblocks dependency-directed
+/// backjumping on cardinality clashes (wine MISSED 34→31, −25% wall, FP=0;
+/// see `docs/backjump-reconcile-2026-06-06.md`). **Default on** as of the flip
+/// (2026-06-06): sound by construction, FP=0 across the cardinality/nominal
+/// corpus, and inert on the EL/Horn corpus (Horn-shortcircuited, never enters
+/// the wedge cardinality path). Set `RUSTDL_PRECISE_CARD_DEPS=0` to revert to the
+/// conservative `DepSet::ALL` behaviour.
+#[must_use]
+pub fn hyper_precise_card_deps_enabled() -> bool {
+    std::env::var_os("RUSTDL_PRECISE_CARD_DEPS").is_none_or(|v| v != "0" && !v.is_empty())
+}
+
 /// HF5: whether the wedge is allowed to *trust* the engine's `Sat`
 /// verdict (concluding "not subsumed" without consulting the tableau).
 /// `Unsat` is sound by construction for any ontology; `Sat` is sound
@@ -914,6 +934,9 @@ impl HyperCache {
         if hyper_double_block_enabled() {
             engine = engine.with_double_blocking();
         }
+        if hyper_precise_card_deps_enabled() {
+            engine = engine.with_precise_card_deps();
+        }
         match engine.decide_with_deadline(HYPER_WEDGE_DEPTH, deadline) {
             HyperResult::Unsat => HyperVerdict::Subsumed,
             HyperResult::Sat => HyperVerdict::NotSubsumed,
@@ -942,6 +965,9 @@ impl HyperCache {
         if hyper_double_block_enabled() {
             engine = engine.with_double_blocking();
         }
+        if hyper_precise_card_deps_enabled() {
+            engine = engine.with_precise_card_deps();
+        }
         match engine.decide_with_deadline(HYPER_WEDGE_DEPTH, deadline) {
             HyperResult::Unsat => LabelOracle::Unsat,
             HyperResult::Sat => engine

{rustdl-0.3.4 → rustdl-0.3.6}/crates/owl-dl-reasoner/tests/konclude_closure_diff.rs

@@ -390,7 +390,11 @@ fn wine_closure_matches_konclude() {
         eprintln!("SKIP: missing wine fixture");
         return;
     }
-    let (_r, _k, fp, _m) = diff_corpus_ontology("wine", input, truth, 200);
+    let budget = std::env::var("RUSTDL_TEST_PAIR_MS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(200);
+    let (_r, _k, fp, _m) = diff_corpus_ontology("wine", input, truth, budget);
     assert_eq!(
         fp, 0,
         "wine has FPs — soundness regression on nominals/datatypes"