/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "COntologyInspector.h"
namespace Konclude {
namespace Reasoner {
namespace Ontology {
COntologyInspector::COntologyInspector() {
}
COntologyInspector::~COntologyInspector() {
}
COntologyStructureSummary *COntologyInspector::createStructureSummary(CConcreteOntology *ontology) {
COntologyStructureSummary *ontStrSum = inspectOntology(ontology);
if (ontStrSum) {
ontology->setStructureSummary(ontStrSum);
}
return ontStrSum;
}
CBOXSET *COntologyInspector::createConceptContainsSet(CConcept *concept, CTBox *tBox, CBOXSET *containsSet) {
if (!containsSet) {
containsSet = new CBOXSET();
}
QList checkList;
checkList.append(concept);
CSortedNegLinker *conIt = 0;
while (!checkList.isEmpty()) {
CConcept *checkConcept = checkList.takeFirst();
if (!containsSet->contains(checkConcept)) {
containsSet->insert(checkConcept);
// collect new dependencies
CRole *role = checkConcept->getRole();
if (role) {
CSortedNegLinker *superRoleIt = role->getIndirectSuperRoleList();
while (superRoleIt) {
CRole *superRole = superRoleIt->getData();
conIt = superRole->getDomainConceptList();
while (conIt) {
CConcept *con = conIt->getData();
checkList.append(con);
conIt = conIt->getNext();
}
conIt = superRole->getRangeConceptList();
while (conIt) {
CConcept *con = conIt->getData();
checkList.append(con);
conIt = conIt->getNext();
}
superRoleIt = superRoleIt->getNext();
}
}
conIt = checkConcept->getOperandList();
while (conIt) {
CConcept *con = conIt->getData();
checkList.append(con);
conIt = conIt->getNext();
}
}
}
return containsSet;
}
COntologyInspector *COntologyInspector::createGCIConceptSet(CTBox *tBox) {
CConceptVector *conVec = tBox->getConceptVector();
qint64 conCount = conVec->getItemCount();
CConcept *topCon = conVec->getData(1);
if (topCon) {
CContext* tBoxContext = tBox->getBoxContext();
CBOXSET *gciContainsSet = createConceptContainsSet(topCon,tBox,CObjectParameterizingAllocator< CBOXSET,CContext* >::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(tBoxContext),tBoxContext));
tBox->setGCIConceptSet(gciContainsSet);
}
return this;
}
COntologyStructureSummary* COntologyInspector::inspectConcept(CConcreteOntology *ontology, CConcept* concept, bool negation, COntologyStructureSummary *ontStructSum) {
qint64 conOpTag = concept->getDefinitionOperatorTag();
bool isClass = concept->hasClassName();
bool opCount = concept->getOperandCount() > 0;
cint64 parm = concept->getParameter();
CSortedNegLinker* opLinker = concept->getOperandList();
for (CSortedNegLinker* opLinkerIt = opLinker; opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
if (opLinkerIt->isNegated()) {
CConcept* opConcept = opLinkerIt->getData();
CConceptOperator* conOperator = opConcept->getConceptOperator();
if (!conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
ontStructSum->setNegationDisjunctionsOccurrence();
}
}
}
CRole* role = concept->getRole();
if (role && role->isDataRole()) {
ontStructSum->setDatatypeOccurrence();
}
if (isClass) {
ontStructSum->incClassCount();
}
if (conOpTag == CCATOM) {
ontStructSum->incPrimitiveConceptCount();
if (isClass) {
ontStructSum->incAtomicClassCount();
}
} else {
ontStructSum->incComplexConceptCount();
if (isClass) {
ontStructSum->incComplexClassCount();
}
if (conOpTag == CCPBINDGROUND || conOpTag == CCNOMTEMPLREF || conOpTag == CCVARBINDGROUND) {
ontStructSum->setGroundingOccurrence();
} else if (conOpTag == CCNOT) {
ontStructSum->incConceptNegCount();
ontStructSum->setNegationDisjunctionsOccurrence();
} else if (conOpTag == CCAND) {
ontStructSum->incConceptIntersectionCount();
} else if (conOpTag == CCOR) {
ontStructSum->incConceptUnionCount();
ontStructSum->setNegationDisjunctionsOccurrence();
} else if (conOpTag == CCATMOST) {
ontStructSum->incConceptAtmostCount();
if (opCount) {
ontStructSum->incConceptQualifiedAtmostCount();
} else {
ontStructSum->incConceptNotQualifiedAtmostCount();
}
if (parm == 1) {
ontStructSum->setFunctionalityOccurrence();
ontStructSum->incConceptFunctionalAtmostCount();
} else if (opCount) {
ontStructSum->setQualifiedCardinalityOccurrence();
} else {
ontStructSum->setCardinalityOccurrence();
}
} else if (conOpTag == CCATLEAST) {
ontStructSum->setExistensialOccurrence();
ontStructSum->incConceptAtleastCount();
if (opCount) {
ontStructSum->incConceptQualifiedAtleastCount();
if (parm != 1) {
ontStructSum->setQualifiedCardinalityOccurrence();
}
} else {
ontStructSum->incConceptNotQualifiedAtleastCount();
if (parm != 1) {
ontStructSum->setCardinalityOccurrence();
}
}
} else if (conOpTag == CCALL) {
ontStructSum->incConceptOnlyCount();
ontStructSum->setExistensialOccurrence();
} else if (conOpTag == CCSOME || conOpTag == CCAQSOME) {
ontStructSum->incConceptSomeCount();
ontStructSum->setExistensialOccurrence();
} else if (conOpTag == CCEQ) {
ontStructSum->setNegationDisjunctionsOccurrence();
ontStructSum->incConceptEquivalenceCount();
} else if (conOpTag == CCSUB) {
ontStructSum->incConceptSubclassCount();
} else if (conOpTag == CCVALUE) {
ontStructSum->incConceptValueCount();
ontStructSum->setNominalIndividualOccurrence();
} else if (conOpTag == CCNOMINAL) {
ontStructSum->incConceptNominalIndividualCount();
ontStructSum->setNominalIndividualOccurrence();
ontStructSum->setNegationDisjunctionsOccurrence();
} else if (conOpTag == CCSELF) {
ontStructSum->incConceptSelfCount();
} else if (conOpTag == CCDATATYPE || CCDATALITERAL || CCDATARESTRICTION) {
}
}
return ontStructSum;
}
COntologyStructureSummary *COntologyInspector::inspectOntology(CConcreteOntology *ontology) {
COntologyStructureSummary *ontStructSum = new COntologyStructureSummary();
CRBox *rBox = ontology->getDataBoxes()->getRBox();
CRoleVector *roleVec = rBox->getRoleVector();
qint64 roleCount = roleVec->getItemCount();
for (qint64 index = 0; index < roleCount; ++index) {
CRole* role = roleVec->getData(index);
if (role) {
CSortedNegLinker* invEqRoleLinkerIt = role->getInverseEquivalentRoleList();
while (invEqRoleLinkerIt) {
bool neg = invEqRoleLinkerIt->isNegated();
CRole* inEqRole = invEqRoleLinkerIt->getData();
if (neg) {
ontStructSum->setInverseOccurrence();
ontStructSum->incRoleInverseCount();
} else {
ontStructSum->incRoleEquivalenceCount();
}
invEqRoleLinkerIt = invEqRoleLinkerIt->getNext();
}
CSortedNegLinker* disRoleLinkerIt = role->getDisjointRoleList();
while (disRoleLinkerIt) {
ontStructSum->incRoleDisjointCount();
disRoleLinkerIt = disRoleLinkerIt->getNext();
}
CSortedNegLinker* domConLinkerIt = role->getDomainConceptList();
while (domConLinkerIt) {
ontStructSum->incRoleDomainConceptCount();
domConLinkerIt = domConLinkerIt->getNext();
}
CSortedNegLinker* rangeConLinkerIt = role->getRangeConceptList();
while (rangeConLinkerIt) {
ontStructSum->incRoleRangeConceptCount();
rangeConLinkerIt = rangeConLinkerIt->getNext();
}
if (role->isAsymmetric()) {
ontStructSum->incRoleAsymmetricCount();
}
if (role->isSymmetric()) {
ontStructSum->incRoleSymmetricCount();
}
if (role->isTransitive()) {
ontStructSum->setTransitivityOccurrence();
ontStructSum->incRoleTransetivCount();
}
if (role->isReflexive()) {
ontStructSum->incRoleReflexivityCount();
}
if (role->isIrreflexive()) {
ontStructSum->incRoleIrreflexivityCount();
}
if (role->isFunctional()) {
ontStructSum->setFunctionalityOccurrence();
ontStructSum->incRoleFunctionalCount();
}
if (role->isInverseFunctional()) {
ontStructSum->setFunctionalityOccurrence();
ontStructSum->incRoleInverseFunctionalCount();
}
if (role->hasRoleChainSuperSharing()) {
bool allTransChaincs = true;
CXLinker* roleChainLinkerIt = role->getRoleChainSuperSharingLinker();
while (roleChainLinkerIt && allTransChaincs) {
CRoleChain* roleChain = roleChainLinkerIt->getData();
CXLinker* chainRoleLinker = roleChain->getRoleChainLinker();
while (chainRoleLinker) {
CRole* chainRole = chainRoleLinker->getData();
if (chainRole != role) {
ontStructSum->setComplexSubRoleOccurrence();
allTransChaincs = false;
break;
}
chainRoleLinker = chainRoleLinker->getNext();
}
roleChainLinkerIt = roleChainLinkerIt->getNext();
}
if (allTransChaincs) {
ontStructSum->setTransitivityOccurrence();
}
}
CSortedNegLinker* superRoleLinkerIt = role->getSuperRoleList();
while (superRoleLinkerIt) {
if (!superRoleLinkerIt->isNegated()) {
//if (!role->hasEquivalentRole(superRoleLinkerIt->getData())) {
//}
ontStructSum->setRoleHierarchyOccurrence();
}
superRoleLinkerIt = superRoleLinkerIt->getNext();
}
}
}
CABox *aBox = ontology->getDataBoxes()->getABox();
CIndividualVector *indiVec = aBox->getIndividualVector();
qint64 indiCount = indiVec->getItemCount();
CTBox *tBox = ontology->getDataBoxes()->getTBox();
CConceptVector *conVec = tBox->getConceptVector();
qint64 conCount = conVec->getItemCount();
for (qint64 index = 0; index < conCount; ++index) {
CConcept *concept = conVec->getData(index);
if (concept) {
ontStructSum->incConceptCount();
inspectConcept(ontology,concept,false,ontStructSum);
}
}
return ontStructSum;
}
bool COntologyInspector::testOntologyForNonDeterministicConcepts(CConcreteOntology *ontology, COntologyStructureSummary *ontStructSum) {
CStructureFlags structureFlags;
CTBox *tBox = ontology->getDataBoxes()->getTBox();
CABox* aBox = ontology->getDataBoxes()->getABox();
CConcept *topConcept = ontology->getDataBoxes()->getTopConcept();
CConcept *bottomConcept = ontology->getDataBoxes()->getBottomConcept();
QSet< QPair > singleConNegSet;
CDatatypeValueSpacesTriggers* valueSpaceTriggers = ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false);
if (valueSpaceTriggers) {
structureFlags.mValidDeterministic = false;
}
CBOXSET *conceptHash = tBox->getActiveClassConceptSet(false);
if (conceptHash) {
for (CBOXSET::const_iterator it = conceptHash->constBegin(), itEnd = conceptHash->constEnd(); it != itEnd && (structureFlags.mValidDeterministic); ++it) {
CConcept *concept = (*it);
if (concept) {
if (concept->getOperatorCode() == CCEQ) {
structureFlags.mValidDeterministic = false;
} else {
analyseConceptStructureFlags(concept,false,singleConNegSet,nullptr,structureFlags);
}
}
}
}
if (structureFlags.mValidDeterministic && (structureFlags.mUniversalRoleOccurence || structureFlags.mNominalOccurence)) {
CBOXSET* individualSet = aBox->getActiveIndividualSet(false);
if (individualSet) {
for (CBOXSET::const_iterator it = individualSet->constBegin(), itEnd = individualSet->constEnd(); it != itEnd && (structureFlags.mValidDeterministic); ++it) {
CIndividual *indi = (*it);
if (indi) {
CConceptAssertionLinker* assConIt = indi->getAssertionConceptLinker();
while (assConIt) {
CConcept* assCon = assConIt->getData();
bool assConNeg = assConIt->isNegated();
analyseConceptStructureFlags(assCon,assConNeg,singleConNegSet,nullptr,structureFlags);
assConIt = assConIt->getNext();
}
}
}
}
}
if (ontStructSum) {
ontStructSum->setOnlyDeterministicConceptClasses(structureFlags.mValidDeterministic);
}
return structureFlags.mValidDeterministic;
}
bool COntologyInspector::testOntologyForNonELConcepts(CConcreteOntology *ontology, COntologyStructureSummary *ontStructSum) {
CStructureFlags structureFlags;
CTBox *tBox = ontology->getDataBoxes()->getTBox();
CConcept *topConcept = ontology->getDataBoxes()->getTopConcept();
CConcept *bottomConcept = ontology->getDataBoxes()->getBottomConcept();
QSet< QPair > singleConNegSet;
QHash existRoleHash;
CDatatypeValueSpacesTriggers* valueSpaceTriggers = ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false);
if (valueSpaceTriggers) {
structureFlags.mValidEL = false;
}
CBOXSET *conceptHash = tBox->getActiveClassConceptSet(false);
if (conceptHash) {
for (CBOXSET::const_iterator it = conceptHash->constBegin(), itEnd = conceptHash->constEnd(); it != itEnd && (structureFlags.mValidEL); ++it) {
CConcept *concept = (*it);
if (concept) {
if (concept->getOperatorCode() == CCEQ) {
structureFlags.mValidEL = false;
} else {
analyseConceptStructureFlags(concept,false,singleConNegSet,&existRoleHash,structureFlags);
}
}
}
}
if (ontStructSum) {
ontStructSum->setOnlyELConceptClasses(structureFlags.mValidEL);
}
return structureFlags.mValidEL;
}
bool COntologyInspector::analyzeOntologyConceptsStructureFlags(CConcreteOntology *ontology, COntologyStructureSummary *ontStructSum) {
CStructureFlags structureFlags;
CTBox* tBox = ontology->getDataBoxes()->getTBox();
CABox* aBox = ontology->getDataBoxes()->getABox();
CConcept *topConcept = ontology->getDataBoxes()->getTopConcept();
CConcept *bottomConcept = ontology->getDataBoxes()->getBottomConcept();
QSet< QPair > singleConNegSet;
QHash existRoleHash;
CDatatypeValueSpacesTriggers* valueSpaceTriggers = ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false);
if (valueSpaceTriggers) {
structureFlags.mValidEL = false;
structureFlags.mValidDeterministic = false;
}
CBOXSET* conceptSet = tBox->getActiveClassConceptSet(false);
if (conceptSet) {
for (CBOXSET::const_iterator it = conceptSet->constBegin(), itEnd = conceptSet->constEnd(); it != itEnd && (structureFlags.mValidEL || structureFlags.mValidDeterministic || !structureFlags.mNominalOccurence); ++it) {
CConcept *concept = (*it);
if (concept) {
if (concept->getOperatorCode() == CCEQ) {
structureFlags.mValidEL = false;
structureFlags.mValidDeterministic = false;
} else {
analyseConceptStructureFlags(concept,false,singleConNegSet,&existRoleHash,structureFlags);
}
}
}
}
if (structureFlags.mValidDeterministic && (structureFlags.mUniversalRoleOccurence || structureFlags.mNominalOccurence)) {
CBOXSET* individualSet = aBox->getActiveIndividualSet(false);
if (individualSet) {
for (CBOXSET::const_iterator it = individualSet->constBegin(), itEnd = individualSet->constEnd(); it != itEnd && (structureFlags.mValidEL || structureFlags.mValidDeterministic || !structureFlags.mNominalOccurence); ++it) {
CIndividual *indi = (*it);
if (indi) {
CConceptAssertionLinker* assConIt = indi->getAssertionConceptLinker();
while (assConIt) {
CConcept* assCon = assConIt->getData();
bool assConNeg = assConIt->isNegated();
analyseConceptStructureFlags(assCon,assConNeg,singleConNegSet,&existRoleHash,structureFlags);
assConIt = assConIt->getNext();
}
}
}
}
}
if (ontStructSum) {
ontStructSum->setNominalOccurrence(structureFlags.mNominalOccurence);
ontStructSum->setOnlyELConceptClasses(structureFlags.mValidEL);
ontStructSum->setOnlyDeterministicConceptClasses(structureFlags.mValidDeterministic);
}
return structureFlags.mValidEL || structureFlags.mValidDeterministic;
}
bool COntologyInspector::analyseConceptStructureFlags(CConcept* concept, bool negated, QSet< QPair >& singleConNegSet, QHash* existRoleHash, CStructureFlags& structureFlags) {
singleConNegSet.insert(QPair(concept,negated));
QList< QPair > checkConNegList;
checkConNegList.append(QPair(concept,negated));
while (!checkConNegList.isEmpty()) {
QPair conNegPair(checkConNegList.takeFirst());
CConcept* con = conNegPair.first;
bool conNeg = conNegPair.second;
CRole* role = con->getRole();
if (role) {
if (role->getRoleTag() == 1) {
structureFlags.mUniversalRoleOccurence = true;
}
CSortedNegLinker* superRoleIt = role->getIndirectSuperRoleList();
while (superRoleIt) {
CRole* superRole = superRoleIt->getData();
CSortedNegLinker* domConIt = superRole->getDomainConceptList();
while (domConIt) {
CConcept* domCon = domConIt->getData();
bool domConNeg = domConIt->isNegated();
if (!singleConNegSet.contains(QPair(domCon,domConNeg))) {
singleConNegSet.insert(QPair(domCon,domConNeg));
checkConNegList.append(QPair(domCon,domConNeg));
}
domConIt = domConIt->getNext();
}
CSortedNegLinker* ranConIt = superRole->getRangeConceptList();
if (ranConIt) {
structureFlags.mValidEL = false;
while (ranConIt) {
CConcept* ranCon = ranConIt->getData();
bool ranConNeg = ranConIt->isNegated();
if (!singleConNegSet.contains(QPair(ranCon,ranConNeg))) {
singleConNegSet.insert(QPair(ranCon,ranConNeg));
checkConNegList.append(QPair(ranCon,ranConNeg));
}
ranConIt = ranConIt->getNext();
}
}
superRoleIt = superRoleIt->getNext();
}
}
CIndividual* indi = con->getNominalIndividual();
if (indi) {
structureFlags.mValidEL = false;
structureFlags.mNominalOccurence = true;
}
cint64 opCode = con->getOperatorCode();
CConceptOperator* conOperator = con->getConceptOperator();
cint64 param = con->getParameter();
cint64 opCount = con->getOperandCount();
if (!con->hasClassName()) {
if (!conNeg && (opCode == CCOR) && opCount > 1 || conNeg && (opCode == CCAND || opCode == CCEQ) && opCount > 1) {
structureFlags.mValidDeterministic = false;
structureFlags.mValidEL = false;
} else if (!conNeg && (opCode == CCATMOST) || conNeg && (opCode == CCATLEAST)) {
structureFlags.mValidEL = false;
if (opCount >= 1 || !conNeg && (opCode == CCATMOST) && param > 1 || conNeg && (opCode == CCATLEAST) && param > 2) {
structureFlags.mValidDeterministic = false;
}
} else {
if (!existRoleHash) {
if (!conNeg && opCode == CCALL) {
structureFlags.mValidEL = false;
}
}
// TODO: check el, SOME r. and SOME r^-1 is not allowed
// TODO: check el, ALL r. translated into automata concept AQALL also not allowed
}
}
if (existRoleHash) {
if (conNeg && (opCode == CCSOME) || !conNeg && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_AQALL_TYPE))) {
if (existRoleHash->contains(role)) {
if (existRoleHash->value(role) == true) {
structureFlags.mValidEL = false;
}
} else {
existRoleHash->insert(role,false);
}
}
if (conNeg && (opCode == CCALL) || !conNeg && (opCode == CCSOME || opCode == CCAQSOME)) {
if (existRoleHash->contains(role)) {
if (existRoleHash->value(role) == false) {
structureFlags.mValidEL = false;
}
} else {
existRoleHash->insert(role,true);
}
}
}
if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_DATATYPE_RELATED_TYPE)) {
structureFlags.mValidEL = false;
}
bool inspectOperandsNegated = false;
bool inspectOnlySameNegation = false;
if (opCode == CCAQCHOOCE) {
inspectOnlySameNegation = true;
}
if (conNeg && (opCode == CCSOME || opCode == CCALL || opCode == CCAND || opCode == CCEQ || opCode == CCOR)) {
inspectOperandsNegated = true;
}
cint64 inspectOperandCount = opCount;
if (opCode == CCVARBINDJOIN || opCode == CCPBINDCYCLE || conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE)) {
inspectOperandCount = 1;
}
CSortedNegLinker* opConIt = con->getOperandList();
while (opConIt) {
CConcept* opCon = opConIt->getData();
bool opConNeg = opConIt->isNegated()^inspectOperandsNegated;
if (inspectOperandCount-- > 0) {
if (!inspectOnlySameNegation || opConNeg == conNeg) {
if (!singleConNegSet.contains(QPair(opCon,opConNeg))) {
singleConNegSet.insert(QPair(opCon,opConNeg));
checkConNegList.append(QPair(opCon,opConNeg));
}
}
}
opConIt = opConIt->getNext();
}
}
return false;
}
}; // end namespace Ontology
}; // end namespace Reasoner
}; // end namespace Konclude