/*
* 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 .
*
*/
#ifndef KONCLUDE_REASONER_KERNEL_ALGORITHM_CSATISFIABLETASKCLASSIFICATIONMESSAGEANALYSER_H
#define KONCLUDE_REASONER_KERNEL_ALGORITHM_CSATISFIABLETASKCLASSIFICATIONMESSAGEANALYSER_H
// Libraries includes
// Namespace includes
#include "CCalculationAlgorithmContext.h"
// Other includes
#include "Context/CContextBase.h"
#include "Reasoner/Classifier/CClassificationMessageDataObserver.h"
#include "Reasoner/Classifier/CClassificationClassSubsumptionMessageData.h"
#include "Reasoner/Classifier/CClassificationClassSubsumptionMessageData.h"
#include "Reasoner/Classifier/CClassificationUpdatePossibleClassSubsumptionMessageData.h"
#include "Reasoner/Classifier/CClassificationInitializePossibleClassSubsumptionMessageData.h"
#include "Reasoner/Classifier/CClassificationMessageData.h"
#include "Reasoner/Classifier/CClassificationSatisfiableCalculationConceptReferenceLinking.h"
#include "Reasoner/Classifier/CClassificationSatisfiablePossibleSubsumptionCalculationConceptReferenceLinking.h"
#include "Reasoner/Classifier/CClassificationPseudoModelIdentifierMessageData.h"
#include "Reasoner/Consistiser/CSaturationConceptDataItem.h"
#include "Reasoner/Kernel/Task/CSatisfiableCalculationTask.h"
#include "Reasoner/Kernel/Process/Dependency/CDependencyTrackPoint.h"
#include "Reasoner/Kernel/Process/Dependency/CDependencyNode.h"
#include "Reasoner/Kernel/Process/CIndividualProcessNode.h"
#include "Reasoner/Kernel/Process/CIndividualSaturationProcessNode.h"
#include "Reasoner/Ontology/CConceptProcessData.h"
#include "Reasoner/Ontology/CConceptSatisfiableReferenceLinkingData.h"
#include "Reasoner/Ontology/CConceptSaturationReferenceLinkingData.h"
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
using namespace Context;
namespace Reasoner {
using namespace Consistiser;
using namespace Classifier;
using namespace Ontology;
namespace Kernel {
using namespace Task;
using namespace Process::Dependency;
namespace Algorithm {
/*!
*
* \class CSatisfiableTaskClassificationMessageAnalyser
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
class CSatisfiableTaskClassificationMessageAnalyser {
// public methods
public:
//! Constructor
CSatisfiableTaskClassificationMessageAnalyser();
bool readCalculationConfig(CCalculationConfigurationExtension *config);
bool analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext);
CIndividualProcessNode* getCorrectedIndividualID(CIndividualProcessNode* baseIndiNode, CIndividualProcessNodeVector* indiNodeVec, bool* nondetMergedFlag);
void checkCanHaveClashWithModel(CIndividualProcessNode* indiNode, CConcept* concept, bool negated, bool& clashFoundFlag, bool& unknownFlag, bool& clashFreeFlag, cint64 depth, QSet* testedIndividualsSet, CIndividualProcessNode* lastNode, CIndividualProcessNodeVector* indiNodeVec);
void verifySubsumptionPossibleWithModel(CIndividualProcessNode* indiNode, CConcept* testingConcept, CClassificationMessageData* possSubsumMessageData, CCLASSSUBSUMPTIONMESSAGELIST* subsumerList);
// protected methods
protected:
CClassificationMessageData* extractPossibleSubsumptionInformation(CConceptDescriptor* conDes, CIndividualProcessNode* indiNode, CReapplyConceptLabelSet* conSet, CCalculationAlgorithmContext* calcAlgContext);
// protected variables
protected:
class CSaturatedMergedTestItem {
public:
CSaturatedMergedTestItem() {
mSuccessfullyMerged = false;
mSatisfiableMerged = false;
}
public:
bool mSuccessfullyMerged;
bool mSatisfiableMerged;
};
class CConceptNegationTriggerItem {
public:
CConceptNegationTriggerItem() {
mTriggerFlag = false;
mNegationFlag = false;
mConcept = nullptr;
mIndiSatNode = nullptr;
}
public:
bool mTriggerFlag;
bool mNegationFlag;
CConcept* mConcept;
CIndividualSaturationProcessNode* mIndiSatNode;
};
class CIndividualAnalyseProcessItem {
public:
CIndividualAnalyseProcessItem* initIndividualAnalyseProcessItem(cint64 indiID = 0, cint64 rootDistance = 0, CIndividualAnalyseProcessItem* ancItem = nullptr, CIndividualLinkEdge* ancLink = nullptr) {
mRootDistance = rootDistance;
mAncItem = ancItem;
mIndiID = indiID;
mAncLink = ancLink;
return this;
}
public:
cint64 mIndiID;
cint64 mRootDistance;
CIndividualLinkEdge* mAncLink;
CIndividualAnalyseProcessItem* mAncItem;
};
class CPseudoModelAnalyseProcessItem {
public:
CPseudoModelAnalyseProcessItem* initPseudoModelAnalyseProcessItem(cint64 pmModelID = 0, cint64 rootDistance = 0) {
mPMModelID = pmModelID;
mRootDistance = rootDistance;
mNodeLinker = nullptr;
return this;
}
CPseudoModelAnalyseProcessItem* addNodeLinker(CXNegLinker* nodeLinker) {
if (nodeLinker) {
mNodeLinker = nodeLinker->append(mNodeLinker);
}
return this;
}
public:
cint64 mPMModelID;
cint64 mRootDistance;
CXNegLinker* mNodeLinker;
};
typedef QPair TConceptNegationPair;
bool mConfAnalyseSubSumptions;
bool mConfAnalyseAllSubSumptions;
bool mConfAnalyseIdentifierOccurence;
bool mConfAnalysePossibleSubSumptions;
bool mEquivalentAlternativesSaturationMerging;
bool mConfStopAnalyseWhenNotChanging;
cint64 mMaxModelAnalysingDepth;
cint64 mMaxPossibleSubsumerNegationCheckingDepth;
cint64 mMaxSaturatedModelMergingTestRecursionDepth;
CClassPossibleSubsumptionMapIterator* mReusePossSubsumMapIterator;
CPROCESSINGHASH< CConcept*,CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST* >* mMultiplePossSubsumInitAvoidHash;
bool mUseAlwaysConRefLinkDataHash;
QHash* mConRefLinkDataHash;
CTaskMemoryPoolAllocationManager* mTempMemAllocMan;
CContextBase* mTmpContext;
CSatisfiableCalculationTask* mStatCalcTask;
CTaskMemoryPoolAllocationManager* mPMTempMemAllocMan;
CContextBase* mPMTmpContext;
cint64 mMaxPseudoModelDepth;
cint64 mMaxPseudoModelNodes;
cint64 mStatConsideredOtherNodeCount;
cint64 mStatExtractedPossibleSubsumerOtherNodeCount;
cint64 mStatSuccessorModelMergingTestCount;
CPROCESSINGHASH< QPair,CSaturatedMergedTestItem >* mTestSaturatedMergedHash;
CIndividualProcessNode* mLastMergingTestNode;
// private methods
private:
CConceptDescriptor* getIndividualProcessNodeConceptWithSingleAncestorDependency(CIndividualProcessNode* indiNode, CIndividualAnalyseProcessItem* indiAnProcItem, CCalculationAlgorithmContext* calcAlgContext);
bool hasDependencyToAncestor(CIndividualProcessNode* individualNode, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext);
bool testSubsumerCandidatePossibleWithMergedSaturatedModel(CIndividualProcessNode* indiNode, CConcept* equivConcept, CCalculationAlgorithmContext* calcAlgContext);
bool testSubsumerCandidatePossibleWithMergedSaturatedModel(CIndividualProcessNode* indiNode, CConcept* testConcept, bool negation, bool& mergeSatisfieableFlag, CCalculationAlgorithmContext* calcAlgContext);
bool testConceptSetWithSaturatedModelMergable(CIndividualProcessNode* indiNode, CIndividualSaturationProcessNode* saturationIndiNode, bool& mergeClashedFlag, CCalculationAlgorithmContext* calcAlgContext);
bool testRoleSuccessorsWithSaturatedModelMergable(CIndividualProcessNode* indiNode, CIndividualSaturationProcessNode* saturationIndiNode, CCalculationAlgorithmContext* calcAlgContext);
bool testSaturatedExistentialsModelMergable(CIndividualProcessNode* indiNode, CIndividualSaturationProcessNode* saturationIndiNode, CCalculationAlgorithmContext* calcAlgContext);
bool collectSuccessorMergingNodesAndConcepts(CIndividualProcessNode* indiNode, CIndividualSaturationProcessNode* saturationIndiNode, CReapplyRoleSuccessorHash* roleSuccHash, CRole* role, CPROCESSINGLIST& successorList, CPROCESSINGLIST& trivialSuccessorPropagatedConceptList, CPROCESSINGSET& backwardRoleSet, CCalculationAlgorithmContext* calcAlgContext);
bool collectSuccessorMergingNodesAndConcepts(CIndividualSaturationProcessNode* excludeSaturationIndiNode, CRole* role, CPROCESSINGLIST& successorList, CPROCESSINGLIST& trivialSuccessorPropagatedConceptList, CPROCESSINGSET& backwardRoleSet, CPROCESSINGLIST& nextSuccessorList, CPROCESSINGLIST& nextTrivialSuccessorPropagatedConceptList, CPROCESSINGSET& nextBackwardRoleSet, CPROCESSINGHASH& successorInfluenceConceptsHash, CCalculationAlgorithmContext* calcAlgContext);
bool collectEquivalenceConceptAlternatives(CIndividualProcessNode* indiNode, CConcept* testConcept, bool testConceptNegation, CPROCESSINGSET< QPair >& alternativesSet, CPROCESSINGHASH< QPair,CSaturatedMergedTestItem >* testSaturatedMergedHash, bool& oneMergeSatisfieableFlag, bool& allMergeUnsatisfieableFlag, CCalculationAlgorithmContext* calcAlgContext);
bool testEquivalenceConceptAlternatives(CIndividualProcessNode* indiNode, CPROCESSINGSET< QPair >& alternativesSet, CPROCESSINGHASH< QPair,CSaturatedMergedTestItem >* testSaturatedMergedHash, bool& oneMergeSatisfieableFlag, bool& allMergeUnsatisfieableFlag, CCalculationAlgorithmContext* calcAlgContext);
CIndividualSaturationProcessNode* getSaturatedIndividualNodeForConcept(CConcept* concept, bool conceptNegation, CCalculationAlgorithmContext* calcAlgContext);
CIndividualSaturationProcessNode* getExistentialSaturatedIndividualNodeForConcept(CConcept* concept, CCalculationAlgorithmContext* calcAlgContext);
bool testSaturatedSuccessorModelMergable(CIndividualSaturationProcessNode* existentialIndiNode, CPROCESSINGLIST& successorList, CPROCESSINGLIST* trivialSuccessorPropagatedConceptList, CPROCESSINGSET& backwardRoleSet, cint64 remainingMergingDepth, cint64& remainingMergingCount, CCalculationAlgorithmContext* calcAlgContext);
bool testSingleSaturatedSuccessorModelMergable(CIndividualSaturationProcessNode* existentialIndiNode, CPROCESSINGLIST& successorList, CPROCESSINGLIST* trivialSuccessorPropagatedConceptList, CPROCESSINGSET& backwardRoleSet, cint64 remainingMergingDepth, cint64& remainingMergingCount, CCalculationAlgorithmContext* calcAlgContext);
bool testMultipleSaturatedSuccessorModelMergable(CIndividualSaturationProcessNode* existentialIndiNode, CPROCESSINGLIST& successorList, CPROCESSINGLIST* trivialSuccessorPropagatedConceptList, CPROCESSINGSET& backwardRoleSet, cint64 remainingMergingDepth, cint64& remainingMergingCount, CCalculationAlgorithmContext* calcAlgContext);
bool addAutomateTransactionConcepts(CConcept* concept, bool negation, CRole* role, CPROCESSINGLIST& successorList, CPROCESSINGLIST& trivialConceptTestingList, CCalculationAlgorithmContext* calcAlgContext);
bool collectTrivialPropagationTestingConcepts(CConcept* concept, bool negation, CPROCESSINGLIST& trivialConceptTestingList, CCalculationAlgorithmContext* calcAlgContext);
// private variables
private:
};
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude
#endif // KONCLUDE_REASONER_KERNEL_ALGORITHM_CSATISFIABLETASKCLASSIFICATIONMESSAGEANALYSER_H