ontocore-reasoner 0.15.0

OntoLogos-backed reasoner facade for OntoCore (ontocore-*)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use ontocore_catalog::{ClassHierarchy, SubclassEdge};
use ontologos_core::{EntityKind, Ontology};

/// Asserted subclass edges taken from the ontology actually loaded for reasoning
/// (including open-buffer overrides), not from a separately indexed catalog.
pub fn asserted_hierarchy_from_ontology(ontology: &Ontology) -> ClassHierarchy {
    let mut edges = Vec::new();
    for (id, entity) in ontology.entities().iter() {
        if entity.kind != EntityKind::Class {
            continue;
        }
        let Ok(child) = ontology.resolve_iri(entity.iri).map(|s| s.to_string()) else {
            continue;
        };
        for &parent_id in ontology.direct_superclasses(id) {
            let Ok(parent_entity) = ontology.entity(parent_id) else {
                continue;
            };
            let Ok(parent) = ontology.resolve_iri(parent_entity.iri).map(|s| s.to_string()) else {
                continue;
            };
            edges.push(SubclassEdge { child: child.clone(), parent });
        }
    }
    crate::result::hierarchy_from_edges(edges)
}

pub fn subclass_edges_from_ontology(
    ontology: &Ontology,
    asserted: &ClassHierarchy,
) -> Vec<(String, String)> {
    let asserted_set: std::collections::BTreeSet<(String, String)> =
        asserted.edges.iter().map(|e| (e.child.clone(), e.parent.clone())).collect();

    let mut edges = Vec::new();
    for (id, entity) in ontology.entities().iter() {
        if entity.kind != EntityKind::Class {
            continue;
        }
        let child = match ontology.resolve_iri(entity.iri) {
            Ok(s) => s.to_string(),
            Err(_) => continue,
        };
        for &parent_id in ontology.direct_superclasses(id) {
            let parent_entity = match ontology.entity(parent_id) {
                Ok(e) => e,
                Err(_) => continue,
            };
            let parent = match ontology.resolve_iri(parent_entity.iri) {
                Ok(s) => s.to_string(),
                Err(_) => continue,
            };
            if !asserted_set.contains(&(child.clone(), parent.clone())) {
                edges.push((child.clone(), parent));
            }
        }
    }
    edges
}