/*
* 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 "CPartialPruningTaxonomy.h"
namespace Konclude {
namespace Reasoner {
namespace Classifier {
CPartialPruningTaxonomy::CPartialPruningTaxonomy(CConcept *topConcept, CConcept *bottomConcept) : CTaxonomy(new CPartialPruningHierarchyNode(topConcept),new CPartialPruningHierarchyNode(bottomConcept)) {
activeNodeSet.insert(bottomNode);
confPruneRelations = true;
confDerivateRelations = true;
statistics = 0;
testCompStatistics = 0;
}
CPartialPruningTaxonomy::~CPartialPruningTaxonomy() {
if (statistics) {
delete statistics;
}
}
CPartialPruningTaxonomy *CPartialPruningTaxonomy::createStatistics(CClassifierStatistics *nextClassificationStatistics) {
testCompStatistics = nextClassificationStatistics;
if (!statistics) {
statistics = new CClassifierStatistics(nextClassificationStatistics);
}
return this;
}
CPartialPruningTaxonomy *CPartialPruningTaxonomy::readConfig(CConfigurationBase *config) {
confPruneRelations = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Classification.PruneSubsumptionRelations",false);
confDerivateRelations = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Classification.DerivateSubsumptionRelations",false);
return this;
}
CTaxonomy *CPartialPruningTaxonomy::setConceptSatisfiable(CConcept *concept, bool satisfiable) {
if (satisfiable) {
CHierarchyNode *conNode = getHierarchyNode(concept);
if (conNode != topNode && !conNode->hasParentNode(topNode)) {
activeNodeSet.insert(conNode);
topNode->makeChild(conNode);
conNode->makeChild(bottomNode);
((CPartialPruningHierarchyNode *)topNode)->repairChildNodes(statistics);
((CPartialPruningHierarchyNode *)conNode)->repairParentNodes(statistics);
//((CPartialPruningHierarchyNode *)topNode)->repairChildsParentNodeReplacement(conNode,statistics);
//((CPartialPruningHierarchyNode *)conNode)->repairParentNodeInsertion(topNode,statistics);
conNode->addIncompatiblePredecessorNode(bottomNode);
bottomNode->addIncompatibleSuccessorNode(conNode);
if (statistics) {
// inc statistics to top concepts
statistics->incDerivatedTestedSubsumptionCount(topNode->getEquivalentConceptCount()*conNode->getEquivalentConceptCount());
// inc statistics to bottom concepts
statistics->incDerivatedTestedSubsumptionCount(bottomNode->getEquivalentConceptCount()*conNode->getEquivalentConceptCount());
statistics->incPrunedTestedSubsumptionCount(bottomNode->getEquivalentConceptCount()*conNode->getEquivalentConceptCount());
}
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)conNode)->propagateTransitiveRelations(statistics);
}
} else if (conNode == topNode) {
activeNodeSet.insert(topNode);
topNode->addIncompatiblePredecessorNode(bottomNode);
bottomNode->addIncompatibleSuccessorNode(topNode);
if (statistics) {
statistics->incDerivatedTestedSubsumptionCount(bottomNode->getEquivalentConceptCount()*topNode->getEquivalentConceptCount());
statistics->incPrunedTestedSubsumptionCount(bottomNode->getEquivalentConceptCount()*topNode->getEquivalentConceptCount());
}
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)conNode)->propagateTransitiveRelations(statistics);
}
}
} else {
CHierarchyNode *conNode = getHierarchyNode(concept,false);
activeNodeSet.remove(conNode);
if (conNode == topNode) {
topNode = bottomNode;
}
bottomNode->addEquivalentConcept(concept);
conNodeHash.insert(concept,bottomNode);
}
#ifdef DEBUGTESTTAXONOMYCONSITENCE
testTaxonomyConsistence();
#endif
return this;
}
CTaxonomy *CPartialPruningTaxonomy::setConceptSubsumption(CConcept *subsumerConcept, CConcept *subsumedConcept) {
CHierarchyNode *subsumedNode = getHierarchyNode(subsumedConcept);
CHierarchyNode *subsumerNode = getHierarchyNode(subsumerConcept);
if (subsumedNode != subsumerNode && !subsumedNode->hasSuccessorNode(subsumerNode)) {
bool makeEquivalent = subsumerNode->hasSuccessorNode(subsumedNode);
if (makeEquivalent) {
//taxString = getConceptHierarchyString();
((CPartialPruningHierarchyNode *)subsumedNode)->mergeToParentNode(subsumerNode,statistics);
QList *eqList = subsumedNode->getEquivalentConceptList();
foreach (CConcept *concept, *eqList) {
CHierarchyNode *prevNode = conNodeHash.value(concept);
if (prevNode != subsumedNode) {
setInactiveNode(prevNode);
conNodeHash.insert(concept,subsumedNode);
}
}
//QString taxString2 = getConceptHierarchyString();
#ifdef DEBUGTESTTAXONOMYCONSITENCE
testTaxonomyConsistence();
#endif
} else {
subsumedNode->makeChild(subsumerNode);
// for all common predecessors and successors repair quasi ordering relation
((CPartialPruningHierarchyNode *)subsumedNode)->repairChildNodes(statistics);
((CPartialPruningHierarchyNode *)subsumedNode)->repairParentNodes(statistics);
((CPartialPruningHierarchyNode *)subsumerNode)->repairParentNodes(statistics);
((CPartialPruningHierarchyNode *)subsumerNode)->repairChildNodes(statistics);
//((CPartialPruningHierarchyNode *)subsumedNode)->repairChildsParentNodeReplacement(subsumerNode,statistics);
//((CPartialPruningHierarchyNode *)subsumerNode)->repairParentNodeInsertion(subsumedNode,statistics);
}
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)subsumerNode)->propagateTransitiveRelations(statistics);
((CPartialPruningHierarchyNode *)subsumedNode)->propagateTransitiveRelations(statistics);
}
}
#ifdef DEBUGTESTTAXONOMYCONSITENCE
testTaxonomyConsistence();
#endif
return this;
}
CTaxonomy *CPartialPruningTaxonomy::setConceptNotSubsumption(CConcept *notSubsumerConcept, CConcept *notSubsumedConcept) {
CHierarchyNode *notSubsumedNode = getHierarchyNode(notSubsumedConcept);
CHierarchyNode *notSubsumerNode = getHierarchyNode(notSubsumerConcept);
if (statistics) {
statistics->incPrunedTestedSubsumptionCount(-notSubsumedNode->getEquivalentConceptCount()*notSubsumerNode->getEquivalentConceptCount());
}
if (confPruneRelations) {
((CPartialPruningHierarchyNode *)notSubsumerNode)->pruneTransitiveRelations(notSubsumedNode,statistics);
}
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)notSubsumerNode)->propagateTransitiveRelations(statistics);
((CPartialPruningHierarchyNode *)notSubsumedNode)->propagateTransitiveRelations(statistics);
}
#ifdef DEBUGTESTTAXONOMYCONSITENCE
testTaxonomyConsistence();
#endif
return this;
}
CTaxonomy *CPartialPruningTaxonomy::setConceptDisjoints(CConcept *disjointConcept1, CConcept *disjointConcept2) {
CHierarchyNode *disjNode1 = getHierarchyNode(disjointConcept1);
CHierarchyNode *disjNode2 = getHierarchyNode(disjointConcept2);
if (!disjNode1->hasIncompatiblePredecessorNode(disjNode2)) {
if (confPruneRelations) {
((CPartialPruningHierarchyNode *)disjNode1)->pruneTransitiveRelations(disjNode2,statistics);
}
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)disjNode1)->propagateTransitiveRelations(statistics);
((CPartialPruningHierarchyNode *)disjNode2)->propagateTransitiveRelations(statistics);
}
}
if (!disjNode2->hasIncompatiblePredecessorNode(disjNode1)) {
if (confPruneRelations) {
((CPartialPruningHierarchyNode *)disjNode2)->pruneTransitiveRelations(disjNode1,statistics);
}
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)disjNode2)->propagateTransitiveRelations(statistics);
((CPartialPruningHierarchyNode *)disjNode1)->propagateTransitiveRelations(statistics);
}
}
disjNode2->makeDisjoint(disjNode1);
if (confDerivateRelations) {
((CPartialPruningHierarchyNode *)disjNode2)->propagateTransitiveRelations(statistics);
((CPartialPruningHierarchyNode *)disjNode1)->propagateTransitiveRelations(statistics);
}
#ifdef DEBUGTESTTAXONOMYCONSITENCE
testTaxonomyConsistence();
#endif
return this;
}
CHierarchyNode *CPartialPruningTaxonomy::createHierarchyNode(CConcept *concept) {
return new CPartialPruningHierarchyNode(concept);
}
void CPartialPruningTaxonomy::testTaxonomyConsistence() {
//#ifdef DEBUGTESTTAXONOMYCONSITENCE
// taxString = getConceptHierarchyString();
//#endif
//for (QList::iterator it = nodeContainer.begin(); it != nodeContainer.end(); ++it) {
// CHierarchyNode* node = *it;
// if (node->getParentNodeSet()->isEmpty() && node->isActive() && node->getOneEquivalentConcept()->getConceptTag() != 0 && node->getOneEquivalentConcept()->getConceptTag() != 1) {
// bool bug = true;
// }
//}
//for (QHash::iterator conIt = conNodeHash.begin(), conItEnd = conNodeHash.end(); conIt != conItEnd; ++conIt) {
// CConcept* con = conIt.key();
// cint count = 0;
// CHierarchyNode* firstNode = nullptr;
// for (QList::iterator it = nodeContainer.begin(); it != nodeContainer.end(); ++it) {
// CHierarchyNode* node = *it;
// if (node->isActive() && node->getEquivalentConceptList()->count(con) > 0) {
// count += node->getEquivalentConceptList()->count(con);
// if (count > 1) {
// bool bug = true;
// }
// firstNode = node;
// }
// }
//}
//if (testCompStatistics) {
// testSubsumptionStatistics(testCompStatistics->getTestedSubsumptionCount());
//}
//for (QHash::const_iterator it = conNodeHash.constBegin(), itEnd = conNodeHash.constEnd(); it != itEnd; ++it) {
// CHierarchyNode *node = *it;
//if (node->getEquivalentConceptsNodeString() == "#Existential" || node->getEquivalentConceptsNodeString() == "#EliminateExistential2") {
// foreach (CHierarchyNode *otherNode, *node->getIncompatiblePredecessorNodeSet()) {
// if (otherNode->getEquivalentConceptsNodeString() == "#Existential" || otherNode->getEquivalentConceptsNodeString() == "#EliminateExistential2") {
// bool bug = true;
// }
// }
// foreach (CHierarchyNode *otherNode, *node->getSuccessorNodeSet()) {
// if (otherNode->getEquivalentConceptsNodeString() == "#Existential" || otherNode->getEquivalentConceptsNodeString() == "#EliminateExistential2") {
// bool bug = true;
// }
// }
//}
// if (isActiveNode(node)) {
// bool consistence = true;
// foreach (CHierarchyNode *otherNode, node->getPredecessorNodeList()) {
// if (isActiveNode(otherNode) && node != bottomNode) {
// if (node->hasIncompatiblePredecessorNode(otherNode)) {
// consistence = false;
// }
// }
// }
// foreach (CHierarchyNode *otherNode, node->getSuccessorNodeList()) {
// if (otherNode != bottomNode && node->hasIncompatibleSuccessorNode(otherNode) && isActiveNode(otherNode)) {
// consistence = false;
// }
// }
// foreach (CHierarchyNode *otherNode, node->getChildNodeList()) {
// if (!otherNode->hasParentNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// if (!otherNode->hasPredecessorNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// }
// foreach (CHierarchyNode *otherNode, node->getParentNodeList()) {
// if (!otherNode->hasChildNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// if (!otherNode->hasSuccessorNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// }
// foreach (CHierarchyNode *otherNode, node->getPredecessorNodeList()) {
// if (!otherNode->hasSuccessorNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// }
// foreach (CHierarchyNode *otherNode, node->getSuccessorNodeList()) {
// if (!otherNode->hasPredecessorNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// }
// foreach (CHierarchyNode *otherNode, *node->getIncompatiblePredecessorNodeSet()) {
// if (!otherNode->hasIncompatibleSuccessorNode(node) && isActiveNode(otherNode) && node != bottomNode) {
// consistence = false;
// }
// }
// foreach (CHierarchyNode *otherNode, *node->getIncompatibleSuccessorNodeSet()) {
// if (!otherNode->hasIncompatiblePredecessorNode(node) && isActiveNode(otherNode)) {
// consistence = false;
// }
// }
// if (!consistence) {
// LOG(ERROR,"::Konclude::Taxonomy::PartialPruningTaxonomy",logTr("Taxonomy inconsistence detected."),this);
// }
// }
//}
}
void CPartialPruningTaxonomy::testSubsumptionStatistics(qint64 subsumCount) {
qint64 testSubSumCount = 0;
QSet checkedSet;
for (QHash::const_iterator it = conNodeHash.constBegin(), itEnd = conNodeHash.constEnd(); it != itEnd; ++it) {
CHierarchyNode *node = *it;
qint64 thisNodeSubSumCount = 0;
if (isActiveNode(node) && !checkedSet.contains(node)) {
checkedSet.insert(node);
if (node->getEquivalentConceptCount() > 1) {
thisNodeSubSumCount += node->getEquivalentConceptCount();
}
foreach (CHierarchyNode *otherNode, node->getPredecessorNodeList()) {
if (isActiveNode(otherNode)) {
thisNodeSubSumCount += node->getEquivalentConceptCount() * otherNode->getEquivalentConceptCount();
}
}
foreach (CHierarchyNode *otherNode, *node->getIncompatiblePredecessorNodeSet()) {
if (isActiveNode(otherNode)) {
thisNodeSubSumCount += node->getEquivalentConceptCount() * otherNode->getEquivalentConceptCount();
}
}
}
testSubSumCount += thisNodeSubSumCount;
}
if (subsumCount != testSubSumCount) {
bool bug = true;
}
}
CTaxonomy *CPartialPruningTaxonomy::completeUnknownAsNonSubsumptions() {
foreach (CHierarchyNode *updateNode, bottomNode->getParentNodeList()) {
QSet *parentNodeSet = updateNode->getParentNodeSet();
for (QSet::const_iterator it1 = parentNodeSet->constBegin(), it1End = parentNodeSet->constEnd(); it1 != it1End; ++it1) {
CHierarchyNode *parentNode(*it1);
if (!updateNode->hasIncompatibleSuccessorNode(parentNode)) {
setConceptNotSubsumption(parentNode->getOneEquivalentConcept(),updateNode->getOneEquivalentConcept());
}
QSet *predNodeSet = updateNode->getPredecessorNodeSet();
for (QSet::const_iterator it1 = predNodeSet->constBegin(), it1End = predNodeSet->constEnd(); it1 != it1End; ++it1) {
CHierarchyNode *predNode(*it1);
QSet *predChildNodeSet = predNode->getChildNodeSet();
for (QSet::const_iterator it2 = predChildNodeSet->constBegin(), it2End = predChildNodeSet->constEnd(); it2 != it2End; ++it2) {
CHierarchyNode *predChildNode(*it2);
for (QSet::const_iterator it3 = predChildNodeSet->constBegin(), it3End = predChildNodeSet->constEnd(); it3 != it3End; ++it3) {
CHierarchyNode *otherPredChildNode(*it3);
if (predChildNode != otherPredChildNode) {
if (!predChildNode->hasIncompatiblePredecessorNode(otherPredChildNode)) {
setConceptNotSubsumption(predChildNode->getOneEquivalentConcept(),otherPredChildNode->getOneEquivalentConcept());
}
}
}
if (predChildNode != updateNode) {
if (!updateNode->hasPredecessorNode(predChildNode) && !updateNode->hasIncompatiblePredecessorNode(predChildNode)) {
setConceptNotSubsumption(updateNode->getOneEquivalentConcept(),predChildNode->getOneEquivalentConcept());
}
if (!predChildNode->hasIncompatibleSuccessorNode(predNode)) {
setConceptNotSubsumption(predNode->getOneEquivalentConcept(),predChildNode->getOneEquivalentConcept());
}
}
}
}
}
}
return this;
}
}; // end namespace Classifier
}; // end namespace Reasoner
}; // end namespace Konclude