/// <summary>
/// Checks if the given aclass can be set disjointwith the given bclass
/// </summary>
internal static Boolean CheckDisjointWithCompatibility(RDFOntologyClassModel classModel,
RDFOntologyClass aClass,
RDFOntologyClass bClass)
{
return(!classModel.CheckIsSubClassOf(aClass, bClass) &&
!classModel.CheckIsSuperClassOf(aClass, bClass) &&
!classModel.CheckIsEquivalentClassOf(aClass, bClass));
}
/// <summary>
/// Checks if the given childclass can be set subclassof the given motherclass
/// </summary>
internal static Boolean CheckSubClassOfCompatibility(RDFOntologyClassModel classModel,
RDFOntologyClass childClass,
RDFOntologyClass motherClass)
{
return(!classModel.CheckIsSubClassOf(motherClass, childClass) &&
!classModel.CheckIsEquivalentClassOf(motherClass, childClass) &&
!classModel.CheckIsDisjointClassWith(motherClass, childClass));
}
/// <summary>
/// Enlists the disjointClasses with the given class within the given class model
/// </summary>
public static RDFOntologyClassModel EnlistDisjointClassesWith(RDFOntologyClass ontClass,
RDFOntologyClassModel classModel)
{
var result = new RDFOntologyClassModel();
if (ontClass != null && classModel != null)
{
result = RDFSemanticsUtilities.EnlistDisjointClassesWith_Core(ontClass, classModel, null)
.RemoveClass(ontClass); //Safety deletion
}
return(result);
}
/// <summary>
/// Checks if the given ontology class is compatible with 'rdfs:Literal' within the given class model
/// </summary>
public static Boolean IsLiteralCompatibleClass(RDFOntologyClass ontClass,
RDFOntologyClassModel classModel)
{
var result = false;
if (ontClass != null && classModel != null)
{
result = (ontClass.IsDataRangeClass() ||
ontClass.Equals(RDFVocabulary.RDFS.LITERAL.ToRDFOntologyClass()) ||
IsSubClassOf(ontClass, RDFVocabulary.RDFS.LITERAL.ToRDFOntologyClass(), classModel));
}
return(result);
}
/// <summary>
/// Checks if the given ontology class is compatible with 'rdfs:Literal' within the given class model
/// </summary>
public static Boolean IsLiteralCompatibleClass(RDFOntologyClass ontClass,
RDFOntologyClassModel classModel)
{
var result = false;
if (ontClass != null && classModel != null)
{
result = (ontClass.IsDataRangeClass() ||
ontClass.Equals(RDFBASEOntology.Instance.Model.ClassModel.SelectClass(RDFVocabulary.RDFS.LITERAL.ToString())) ||
IsSubClassOf(ontClass, RDFBASEOntology.Instance.Model.ClassModel.SelectClass(RDFVocabulary.RDFS.LITERAL.ToString()), classModel) ||
IsEquivalentClassOf(ontClass, RDFBASEOntology.Instance.Model.ClassModel.SelectClass(RDFVocabulary.RDFS.LITERAL.ToString()), classModel));
}
return(result);
}
/// <summary>
/// Enlists the superClasses of the given class within the given class model
/// </summary>
public static RDFOntologyClassModel EnlistSuperClassesOf(RDFOntologyClass ontClass, RDFOntologyClassModel classModel) {
var result = new RDFOntologyClassModel();
if (ontClass != null && classModel != null) {
//Step 1: Reason on the given class
result = RDFSemanticsUtilities.EnlistSuperClassesOf_Core(ontClass, classModel);
//Step 2: Reason on the equivalent classes of the given class
foreach(var ec in RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(ontClass, classModel)) {
result = result.UnionWith(RDFSemanticsUtilities.EnlistSuperClassesOf_Core(ec, classModel));
}
}
return result;
}
/// <summary>
/// Enlists the range classes of the given property within the given ontology class model
/// </summary>
public static RDFOntologyClassModel EnlistRangeClassesOf(RDFOntologyProperty ontProperty,
RDFOntologyClassModel classModel)
{
var result = new RDFOntologyClassModel();
if (ontProperty != null && classModel != null)
{
if (ontProperty.Range != null)
{
result = EnlistSubClassesOf(ontProperty.Range, classModel)
.UnionWith(EnlistEquivalentClassesOf(ontProperty.Range, classModel))
.AddClass(ontProperty.Range);
}
}
return(result);
}
/// <summary>
/// Enlists the superClasses of the given class within the given class model
/// </summary>
public static RDFOntologyClassModel EnlistSuperClassesOf(RDFOntologyClass ontClass,
RDFOntologyClassModel classModel)
{
var result = new RDFOntologyClassModel();
if (ontClass != null && classModel != null)
{
//Step 1: Reason on the given class
result = RDFSemanticsUtilities.EnlistSuperClassesOf_Core(ontClass, classModel);
//Step 2: Reason on the equivalent classes
foreach (var ec in EnlistEquivalentClassesOf(ontClass, classModel))
{
result = result.UnionWith(RDFSemanticsUtilities.EnlistSuperClassesOf_Core(ec, classModel));
}
}
return(result);
}
/// <summary>
/// Checks if the given aClass is superClass of the given bClass within the given class model
/// </summary>
public static Boolean IsSuperClassOf(RDFOntologyClass aClass,
RDFOntologyClass bClass,
RDFOntologyClassModel classModel)
{
return(aClass != null && bClass != null && classModel != null ? EnlistSubClassesOf(aClass, classModel).Classes.ContainsKey(bClass.PatternMemberID) : false);
}
/// <summary>
/// Subsumes the "rdfs:subClassOf" taxonomy to discover direct and indirect superClasses of the given class
/// </summary>
internal static RDFOntologyClassModel EnlistSuperClassesOf(RDFOntologyClass ontClass, RDFOntologyClassModel classModel) {
var result = new RDFOntologyClassModel();
// Transitivity of "rdfs:subClassOf" taxonomy: ((A SUPERCLASSOF B) && (B SUPERCLASSOF C)) => (A SUPERCLASSOF C)
foreach(var sc in classModel.Relations.SubClassOf.SelectEntriesBySubject(ontClass)) {
result.AddClass((RDFOntologyClass)sc.TaxonomyObject);
result = result.UnionWith(RDFSemanticsUtilities.EnlistSuperClassesOf((RDFOntologyClass)sc.TaxonomyObject, classModel));
}
return result;
}
internal static RDFOntologyClassModel EnlistDisjointClassesWith_Core(RDFOntologyClass ontClass, RDFOntologyClassModel classModel, Dictionary<Int64, RDFOntologyClass> visitContext) {
var result1 = new RDFOntologyClassModel();
var result2 = new RDFOntologyClassModel();
#region visitContext
if (visitContext == null) {
visitContext = new Dictionary<Int64, RDFOntologyClass>() { { ontClass.PatternMemberID, ontClass } };
}
else {
if (!visitContext.ContainsKey(ontClass.PatternMemberID)) {
visitContext.Add(ontClass.PatternMemberID, ontClass);
}
else {
return result1;
}
}
#endregion
// Inference: ((A DISJOINTWITH B) && (B EQUIVALENTCLASS C)) => (A DISJOINTWITH C)
foreach (var dw in classModel.Relations.DisjointWith.SelectEntriesBySubject(ontClass)) {
result1.AddClass((RDFOntologyClass)dw.TaxonomyObject);
result1 = result1.UnionWith(RDFSemanticsUtilities.EnlistEquivalentClassesOf_Core((RDFOntologyClass)dw.TaxonomyObject, classModel, visitContext));
}
// Inference: ((A DISJOINTWITH B) && (B SUPERCLASS C)) => (A DISJOINTWITH C)
result2 = result2.UnionWith(result1);
foreach (var c in result1) {
result2 = result2.UnionWith(RDFSemanticsUtilities.EnlistSubClassesOf_Core(c, classModel));
}
result1 = result1.UnionWith(result2);
// Inference: ((A EQUIVALENTCLASS B || A SUBCLASSOF B) && (B DISJOINTWITH C)) => (A DISJOINTWITH C)
var compatibleCls = RDFOntologyReasoningHelper.EnlistSuperClassesOf(ontClass, classModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(ontClass, classModel));
foreach (var ec in compatibleCls) {
result1 = result1.UnionWith(RDFSemanticsUtilities.EnlistDisjointClassesWith_Core(ec, classModel, visitContext));
}
return result1;
}
/// <summary>
/// Subsumes the "owl:equivalentClass" taxonomy to discover direct and indirect equivalentClasses of the given class
/// </summary>
internal static RDFOntologyClassModel EnlistEquivalentClassesOf_Core(RDFOntologyClass ontClass,
RDFOntologyClassModel classModel,
Dictionary<Int64, RDFOntologyClass> visitContext) {
var result = new RDFOntologyClassModel();
#region visitContext
if (visitContext == null) {
visitContext = new Dictionary<Int64, RDFOntologyClass>() { { ontClass.PatternMemberID, ontClass } };
}
else {
if (!visitContext.ContainsKey(ontClass.PatternMemberID)) {
visitContext.Add(ontClass.PatternMemberID, ontClass);
}
else {
return result;
}
}
#endregion
// Transitivity of "owl:equivalentClass" taxonomy: ((A EQUIVALENTCLASSOF B) && (B EQUIVALENTCLASS C)) => (A EQUIVALENTCLASS C)
foreach (var ec in classModel.Relations.EquivalentClass.SelectEntriesBySubject(ontClass)) {
result.AddClass((RDFOntologyClass)ec.TaxonomyObject);
result = result.UnionWith(RDFSemanticsUtilities.EnlistEquivalentClassesOf_Core((RDFOntologyClass)ec.TaxonomyObject, classModel, visitContext));
}
return result;
}
/// <summary>
/// Enlists the disjointClasses with the given class within the given class model
/// </summary>
public static RDFOntologyClassModel EnlistDisjointClassesWith(RDFOntologyClass ontClass, RDFOntologyClassModel classModel) {
var result = new RDFOntologyClassModel();
if (ontClass != null && classModel != null) {
result = RDFSemanticsUtilities.EnlistDisjointClassesWith_Core(ontClass, classModel, null).RemoveClass(ontClass);
}
return result;
}
/// <summary>
/// Checks if the given ontology class is range of the given ontology property within the given ontology class model
/// </summary>
public static Boolean IsRangeClassOf(RDFOntologyClass rangeClass,
RDFOntologyProperty ontProperty,
RDFOntologyClassModel classModel)
{
return(rangeClass != null && ontProperty != null && classModel != null ? EnlistRangeClassesOf(ontProperty, classModel).Classes.ContainsKey(rangeClass.PatternMemberID) : false);
}
/// <summary> /// Checks if the given aclass can be set disjointwith the given bclass /// </summary> internal static bool CheckDisjointWithCompatibility(RDFOntologyClassModel classModel, RDFOntologyClass aClass, RDFOntologyClass bClass) => !classModel.CheckIsSubClassOf(aClass, bClass) && !classModel.CheckIsSuperClassOf(aClass, bClass) && !classModel.CheckIsEquivalentClassOf(aClass, bClass);
/// <summary>
/// Checks if the given aClass is disjointClass with the given bClass within the given class model
/// </summary>
public static Boolean IsDisjointClassWith(RDFOntologyClass aClass,
RDFOntologyClass bClass,
RDFOntologyClassModel classModel)
{
return(aClass != null && bClass != null && classModel != null ? EnlistDisjointClassesWith(aClass, classModel).Classes.ContainsKey(bClass.PatternMemberID) : false);
}
/// <summary>
/// Validation rule checking for consistency of rdf:type axioms
/// </summary>
internal static void ClassType(RDFOntology ontology, RDFOntologyValidationReport report) {
RDFSemanticsEvents.RaiseSemanticsInfo("Launched execution of validation rule 'ClassType'");
#region Facts
var disjWithCache = new Dictionary<Int64, RDFOntologyClassModel>();
var litCheckCache = new Dictionary<Int64, Boolean>();
foreach (var fact in ontology.Data) {
var classTypes = new RDFOntologyClassModel();
foreach (var cType in ontology.Data.Relations.ClassType.SelectEntriesBySubject(fact)) {
//ClassTypes of a fact cannot be compatible with "rdfs:Literal"
var cTypeClass = ontology.Model.ClassModel.SelectClass(cType.TaxonomyObject.ToString());
if (cTypeClass != null) {
if (!litCheckCache.ContainsKey(cTypeClass.PatternMemberID)) {
litCheckCache.Add(cTypeClass.PatternMemberID, RDFOntologyReasoningHelper.IsLiteralCompatibleClass(cTypeClass, ontology.Model.ClassModel));
}
if (litCheckCache[cTypeClass.PatternMemberID]) {
report.AddEvidence(new RDFOntologyValidationEvidence(
RDFSemanticsEnums.RDFOntologyValidationEvidenceCategory.Error,
"ClassType",
String.Format("Ontology fact '{0}' has a classtype '{1}' which is compatible with 'rdfs:Literal' and this cannot be possible.", fact, cTypeClass),
String.Format("Review classtypes of ontology fact '{0}'.", fact)
));
}
else {
classTypes.AddClass(cTypeClass);
}
}
}
//ClassTypes of a fact cannot be disjoint
foreach (var cType in classTypes) {
if (!disjWithCache.ContainsKey(cType.PatternMemberID)) {
disjWithCache.Add(cType.PatternMemberID, RDFOntologyReasoningHelper.EnlistDisjointClassesWith(cType, ontology.Model.ClassModel));
}
foreach (var disjWithCType in disjWithCache[cType.PatternMemberID].IntersectWith(classTypes)) {
report.AddEvidence(new RDFOntologyValidationEvidence(
RDFSemanticsEnums.RDFOntologyValidationEvidenceCategory.Error,
"ClassType",
String.Format("Ontology fact '{0}' has both classtypes '{1}' and '{2}', which cannot be compatible because of an 'owl:disjointWith' constraint.", fact, cType, disjWithCType),
String.Format("Review classtypes of ontology fact '{0}'.", fact)
));
}
}
}
#endregion
RDFSemanticsEvents.RaiseSemanticsInfo("Completed execution of validation rule 'ClassType'");
}
/// <summary> /// Checks if the given childclass can be set subclassof the given motherclass /// </summary> internal static bool CheckSubClassOfCompatibility(RDFOntologyClassModel classModel, RDFOntologyClass childClass, RDFOntologyClass motherClass) => !classModel.CheckIsSubClassOf(motherClass, childClass) && !classModel.CheckIsEquivalentClassOf(motherClass, childClass) && !classModel.CheckIsDisjointClassWith(motherClass, childClass);
/// <summary>
/// Checks if the given ontology class is range of the given ontology property within the given ontology class model
/// </summary>
public static Boolean IsRangeClassOf(RDFOntologyClass rangeClass, RDFOntologyProperty ontProperty, RDFOntologyClassModel classModel) {
return (rangeClass != null && ontProperty != null && classModel != null ? RDFOntologyReasoningHelper.EnlistRangeClassesOf(ontProperty, classModel).Classes.ContainsKey(rangeClass.PatternMemberID) : false);
}
internal static RDFOntologyClassModel EnlistSuperClassesOf_Core(RDFOntologyClass ontClass, RDFOntologyClassModel classModel) {
var result1 = new RDFOntologyClassModel();
var result2 = new RDFOntologyClassModel();
// Step 1: Direct subsumption of "rdfs:subClassOf" taxonomy
result1 = RDFSemanticsUtilities.EnlistSuperClassesOf(ontClass, classModel);
// Step 2: Enlist equivalent classes of superclasses
result2 = result2.UnionWith(result1);
foreach(var sc in result1) {
result2 = result2.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(sc, classModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistSuperClassesOf(sc, classModel)));
}
return result2;
}
/// <summary>
/// Enlists the range classes of the given property within the given ontology class model
/// </summary>
public static RDFOntologyClassModel EnlistRangeClassesOf(RDFOntologyProperty ontProperty, RDFOntologyClassModel classModel) {
var result = new RDFOntologyClassModel();
if (ontProperty != null && classModel != null) {
if (ontProperty.Range != null) {
result = RDFOntologyReasoningHelper.EnlistSubClassesOf(ontProperty.Range, classModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(ontProperty.Range, classModel))
.AddClass(ontProperty.Range);
}
}
return result;
}
/// <summary>
/// Checks if the given aClass is equivalentClass of the given bClass within the given class model
/// </summary>
public static Boolean IsEquivalentClassOf(RDFOntologyClass aClass, RDFOntologyClass bClass, RDFOntologyClassModel classModel) {
return(aClass != null && bClass != null && classModel != null ? RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(aClass, classModel).Classes.ContainsKey(bClass.PatternMemberID) : false);
}
/// <summary>
/// Checks if the given ontology class is compatible with 'rdfs:Literal' within the given class model
/// </summary>
public static Boolean IsLiteralCompatibleClass(RDFOntologyClass ontClass, RDFOntologyClassModel classModel) {
var result = false;
if (ontClass != null && classModel != null) {
result = (ontClass.IsDataRangeClass() ||
ontClass.Equals(RDFOntologyVocabulary.Classes.LITERAL) ||
RDFOntologyReasoningHelper.IsSubClassOf(ontClass, RDFOntologyVocabulary.Classes.LITERAL, classModel) ||
RDFOntologyReasoningHelper.IsEquivalentClassOf(ontClass, RDFOntologyVocabulary.Classes.LITERAL, classModel));
}
return result;
}
