/// <summary>
/// SymmetricPropertyEntailment implements data entailments based on 'owl:SymmetricProperty' axiom:
/// ((F1 P F2) AND (P TYPE SYMMETRICPROPERTY)) => (F2 P F1)
/// </summary>
internal static RDFOntologyReasonerReport SymmetricPropertyEntailmentExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
//Calculate the set of available properties on which to perform the reasoning (exclude BASE properties and not-symmetric properties)
var availableprops = ontology.Model.PropertyModel.Where(prop => !RDFOntologyChecker.CheckReservedProperty(prop) &&
prop.IsSymmetricProperty()).ToList();
foreach (var p in availableprops)
{
//Filter the assertions using the current property (F1 P F2)
var pAsns = ontology.Data.Relations.Assertions.SelectEntriesByPredicate(p);
//Iterate those assertions
foreach (var pAsn in pAsns)
{
//Taxonomy-check for securing inference consistency
if (pAsn.TaxonomyObject.IsFact())
{
//Create the inference as a taxonomy entry
var sem_inf = new RDFOntologyTaxonomyEntry(pAsn.TaxonomyObject, p, pAsn.TaxonomySubject).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Data.Relations.Assertions.AddEntry(sem_inf))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.Data, "SymmetricPropertyEntailment", sem_inf));
}
}
}
}
return(report);
}
/// <summary>
/// EquivalentPropertyTransitivity implements structural entailments based on 'owl:EquivalentProperty' taxonomy:
/// ((P1 EQUIVALENTPROPERTY P2) AND (P2 EQUIVALENTPROPERTY P3)) => (P1 EQUIVALENTPROPERTY P3)
/// </summary>
internal static RDFOntologyReasonerReport EquivalentPropertyTransitivityExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
var equivProperty = RDFVocabulary.OWL.EQUIVALENT_PROPERTY.ToRDFOntologyObjectProperty();
//Calculate the set of available properties on which to perform the reasoning (exclude BASE properties and annotation properties)
var availableprops = ontology.Model.PropertyModel.Where(prop => !RDFOntologyChecker.CheckReservedProperty(prop) &&
!prop.IsAnnotationProperty()).ToList();
foreach (var p in availableprops)
{
//Enlist the equivalent properties of the current property
var equivprops = ontology.Model.PropertyModel.GetEquivalentPropertiesOf(p);
foreach (var ep in equivprops)
{
//Create the inference as a taxonomy entry
var sem_infA = new RDFOntologyTaxonomyEntry(p, equivProperty, ep).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
var sem_infB = new RDFOntologyTaxonomyEntry(ep, equivProperty, p).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Model.PropertyModel.Relations.EquivalentProperty.AddEntry(sem_infA))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.PropertyModel, "EquivalentPropertyTransitivity", sem_infA));
}
if (ontology.Model.PropertyModel.Relations.EquivalentProperty.AddEntry(sem_infB))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.PropertyModel, "EquivalentPropertyTransitivity", sem_infB));
}
}
}
return(report);
}
/// <summary>
/// "DomainEntailment (rdfs2) implements structural entailments based on 'rdfs:domain' taxonomy:"
/// "((F1 P F2) AND (P RDFS:DOMAIN C)) => (F1 RDF:TYPE C)"
/// </summary>
internal static RDFOntologyReasonerReport DomainEntailmentExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
var type = RDFVocabulary.RDF.TYPE.ToRDFOntologyObjectProperty();
//Calculate the set of available properties on which to perform the reasoning (exclude BASE properties and annotation properties)
var availableprops = ontology.Model.PropertyModel.Where(prop => !RDFOntologyChecker.CheckReservedProperty(prop) &&
!prop.IsAnnotationProperty()).ToList();
foreach (var p in availableprops)
{
if (p.Domain != null)
{
//Filter the assertions using the current property (F1 P1 F2)
var pAsns = ontology.Data.Relations.Assertions.SelectEntriesByPredicate(p);
//Iterate the related assertions
foreach (var pAsn in pAsns)
{
//Create the inference as a taxonomy entry
var sem_inf = new RDFOntologyTaxonomyEntry(pAsn.TaxonomySubject, type, p.Domain).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Data.Relations.ClassType.AddEntry(sem_inf))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.Data, "DomainEntailment", sem_inf));
}
}
}
}
return(report);
}
/// <summary>
/// ClassTypeEntailment (rdfs9) implements structural entailments based on 'rdf:type' taxonomy:
/// ((F TYPE C1) AND (C1 SUBCLASSOF C2)) => (F TYPE C2)
/// ((F TYPE C1) AND (C1 EQUIVALENTCLASS C2)) => (F TYPE C2)
/// </summary>
internal static RDFOntologyReasonerReport ClassTypeEntailmentExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
var type = RDFVocabulary.RDF.TYPE.ToRDFOntologyObjectProperty();
//Calculate the set of available classes on which to perform the reasoning (exclude BASE classes and literal-compatible classes)
var availableclasses = ontology.Model.ClassModel.Where(cls => !RDFOntologyChecker.CheckReservedClass(cls) &&
!ontology.Model.ClassModel.CheckIsLiteralCompatible(cls));
foreach (var c in availableclasses)
{
//Enlist the members of the current class
var clsMembers = ontology.GetMembersOfNonLiteralCompatibleClass(c);
foreach (var f in clsMembers)
{
//Create the inference as a taxonomy entry
var sem_inf = new RDFOntologyTaxonomyEntry(f, type, c).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Data.Relations.ClassType.AddEntry(sem_inf))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.Data, "ClassTypeEntailment", sem_inf));
}
}
}
return(report);
}
/// <summary>
/// SubPropertyTransitivity (rdfs5) implements structural entailments based on 'rdfs:subPropertyOf' taxonomy:
/// ((P1 SUBPROPERTYOF P2) AND (P2 SUBPROPERTYOF P3)) => (P1 SUBPROPERTYOF P3)
/// ((P1 SUBPROPERTYOF P2) AND (P2 EQUIVALENTPROPERTY P3)) => (P1 SUBPROPERTYOF P3)
/// ((P1 EQUIVALENTPROPERTY P2) AND (P2 SUBPROPERTYOF P3)) => (P1 SUBPROPERTYOF P3)
/// </summary>
internal static RDFOntologyReasonerReport SubPropertyTransitivityExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
var subPropertyOf = RDFVocabulary.RDFS.SUB_PROPERTY_OF.ToRDFOntologyObjectProperty();
//Calculate the set of available properties on which to perform the reasoning (exclude BASE properties and annotation properties)
var availableprops = ontology.Model.PropertyModel.Where(prop => !RDFOntologyChecker.CheckReservedProperty(prop) &&
!prop.IsAnnotationProperty()).ToList();
foreach (var p in availableprops)
{
//Enlist the superproperties of the current property
var superprops = ontology.Model.PropertyModel.GetSuperPropertiesOf(p);
foreach (var sp in superprops)
{
//Create the inference as a taxonomy entry
var sem_inf = new RDFOntologyTaxonomyEntry(p, subPropertyOf, sp).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Model.PropertyModel.Relations.SubPropertyOf.AddEntry(sem_inf))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.PropertyModel, "SubPropertyTransitivity", sem_inf));
}
}
}
return(report);
}
/// <summary>
/// TransitivePropertyEntailment implements data entailments based on 'owl:TransitiveProperty' axiom:
/// ((F1 P F2) AND (F2 P F3) AND (P TYPE TRANSITIVEPROPERTY)) => (F1 P F3)
/// </summary>
internal static RDFOntologyReasonerReport TransitivePropertyEntailmentExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
var transPropCache = new Dictionary <Int64, RDFOntologyData>();
//Calculate the set of available properties on which to perform the reasoning (exclude BASE properties and not-transitive properties)
var availableprops = ontology.Model.PropertyModel.Where(prop => !RDFOntologyChecker.CheckReservedProperty(prop) &&
prop.IsTransitiveProperty()).ToList();
foreach (var p in availableprops)
{
//Filter the assertions using the current property (F1 P F2)
var pAsns = ontology.Data.Relations.Assertions.SelectEntriesByPredicate(p);
//Iterate those assertions
foreach (var pAsn in pAsns)
{
//Taxonomy-check for securing inference consistency
if (pAsn.TaxonomyObject.IsFact())
{
if (!transPropCache.ContainsKey(pAsn.TaxonomySubject.PatternMemberID))
{
transPropCache.Add(pAsn.TaxonomySubject.PatternMemberID, ontology.Data.GetTransitiveAssertionsOf((RDFOntologyFact)pAsn.TaxonomySubject, (RDFOntologyObjectProperty)p));
}
foreach (var te in transPropCache[pAsn.TaxonomySubject.PatternMemberID])
{
//Create the inference as a taxonomy entry
var sem_inf = new RDFOntologyTaxonomyEntry(pAsn.TaxonomySubject, p, te).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Data.Relations.Assertions.AddEntry(sem_inf))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.Data, "TransitivePropertyEntailment", sem_inf));
}
}
}
}
transPropCache.Clear();
}
return(report);
}
/// <summary>
/// InverseOfEntailment implements data entailments based on 'owl:inverseOf' taxonomy:
/// ((F1 P1 F2) AND (P1 INVERSEOF P2)) => (F2 P2 F1)
/// </summary>
internal static RDFOntologyReasonerReport InverseOfEntailmentExec(RDFOntology ontology)
{
var report = new RDFOntologyReasonerReport();
//Calculate the set of available properties on which to perform the reasoning (exclude BASE properties and annotation/datatype properties)
var availableprops = ontology.Model.PropertyModel.Where(prop => !RDFOntologyChecker.CheckReservedProperty(prop) &&
prop.IsObjectProperty()).ToList();
foreach (var p1 in availableprops)
{
//Filter the assertions using the current property (F1 P1 F2)
var p1Asns = ontology.Data.Relations.Assertions.SelectEntriesByPredicate(p1);
//Enlist the inverse properties of the current property
var inverseprops = ontology.Model.PropertyModel.GetInversePropertiesOf((RDFOntologyObjectProperty)p1);
foreach (var p2 in inverseprops)
{
//Iterate the compatible assertions
foreach (var p1Asn in p1Asns)
{
//Taxonomy-check for securing inference consistency
if (p2.IsObjectProperty() && p1Asn.TaxonomyObject.IsFact())
{
//Create the inference as a taxonomy entry
var sem_inf = new RDFOntologyTaxonomyEntry(p1Asn.TaxonomyObject, p2, p1Asn.TaxonomySubject).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.Reasoner);
//Add the inference to the ontology and to the report
if (ontology.Data.Relations.Assertions.AddEntry(sem_inf))
{
report.AddEvidence(new RDFOntologyReasonerEvidence(RDFSemanticsEnums.RDFOntologyReasonerEvidenceCategory.Data, "InverseOfEntailment", sem_inf));
}
}
}
}
}
return(report);
}
