/*
* 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_PREPROCESS_CTRIGGEREDIMPLICATIONBINARYABSORBERPREPROCESS_H
#define KONCLUDE_REASONER_PREPROCESS_CTRIGGEREDIMPLICATIONBINARYABSORBERPREPROCESS_H
// Libraries includes
#include
// Namespace includes
#include "CConcreteOntologyContinuablePreProcess.h"
#include "CConceptRoleIndividualLocator.h"
#include "CConceptTriggerLinker.h"
#include "CConceptRoleIndividualLocator.h"
#include "CNominalSchemaAbsorptionPathLinker.h"
#include "CNominalSchemaAbsorptionBranchLinker.h"
// Other includes
#include "Utilities/CDynamicExpandingMemoryManager.hpp"
#include "Utilities/CSortedNegLinker.hpp"
#include "Config/CConfigDataReader.h"
#include "Reasoner/Generator/CConcreteOntologyInverseRoleBuilder.h"
#include "Reasoner/Ontology/CConceptTextFormater.h"
#include "Reasoner/Ontology/COntologyTextFormater.h"
#include "Reasoner/Ontology/CNominalSchemaTemplate.h"
#include "Reasoner/Ontology/CNominalSchemaTemplateVector.h"
// Logger includes
#include "Logger/CLogger.h"
namespace Konclude {
using namespace Config;
namespace Reasoner {
using namespace Generator;
using namespace Ontology;
namespace Preprocess {
/*!
*
* \class CTriggeredImplicationBinaryAbsorberPreProcess
* \author Andreas Steigmiller
* \version 0.1
* \brief TODO
*
*/
class CTriggeredImplicationBinaryAbsorberPreProcess : public CConcreteOntologyContinuablePreProcess {
// public methods
public:
//! Constructor
CTriggeredImplicationBinaryAbsorberPreProcess();
//! Destructor
virtual ~CTriggeredImplicationBinaryAbsorberPreProcess();
virtual CConcreteOntology* preprocess(CConcreteOntology *ontology, CPreProcessContext* context);
virtual CConcreteOntology* continuePreprocessing();
// protected methods
protected:
typedef QPair TConceptNegationPair;
typedef QPair TOccuredAbsorbablePair;
typedef QPair TConceptPair;
typedef QPair TAbsorptionBranchPair;
void createDisjunctionAbsorptions(bool continuationExtension = false);
void createConceptOfInterestAbsorptions(bool continuationExtension = false);
void asorbForallsToRanges(CConcept* topConcept);
bool collectConjunctions(CConcept* concept, bool negated, QList< TConceptNegationPair >& conjList);
void collectPositiveConcepts(CConcept* concept, bool negated, QSet* positiveConceptSet, bool recursiveDefinition = false);
CConcept* getRoleDomainTriggerConcept(CRole* role);
bool addConceptToImplied(CConcept* impliedConcept, CConcept* concept, bool negated);
bool addSubClassConcept(CConcept* subclassConcept, CConcept* addedConcept, bool negated);
bool addRoleDomainConcept(CRole* role, CConcept* addedConcept, bool negated);
bool addRoleRangeConcept(CRole* role, CConcept* addedConcept, bool negated);
CConcept* createCandidateEquivalentConcept(CConcept* eqConcept);
CConcept* createImpliedConcept();
CConcept* createNewConcept();
CConcept* createImplicationConcept(CConcept* impliedConcept, bool negated);
CConcept* createImplicationTriggerConcept(CConcept* impConcept, bool negated);
bool addImplicationTrigger(CConcept* implConcept, CConcept* triggerConcept, bool negated);
CConcept* createTriggerPropagationConcept(CConcept* destConcept, CRole* backwardPropRole, bool branchTiggerCreation, bool invsereRolePropagation = true);
CConcept* createNominalImplication(CConcept* destConcept, CIndividual* nominalIndi);
CConcept* createDatatypeImplication(CConcept* destConcept, CDatatype* datatype);
CConcept* createDataLiteralImplication(CConcept* destConcept, CDataLiteral* dataLiteral);
CConcept* createDataRestrictionImplication(CConcept* destConcept, CDatatype* datatype, CDataLiteral* dataliteral, cint64 restrictionCode);
bool isEquivalenceConceptTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated, cint64* notAbsorbableOperandsCount = nullptr);
bool isEquivalenceConceptCandidateExtractable(CConcept* orConcept, bool negated);
CConcept* getEquivalenceConceptCandidateTriggeredImplication(CConcept* eqConcept, bool negated);
bool isGCIConceptTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated, cint64* notAbsorbableOperandsCount = nullptr);
bool isConceptImplicationTriggerable(CConcept* concept, bool negated, QHash* conceptEqConAbsorbed);
bool isConceptImplicationTriggerable(CConcept* concept, bool negated, QHash* conceptEqConAbsorbed, cint64* openMultipleOccurCount, QList** dependingCacheList);
bool isConceptSimpleImplicationTriggerable(CConcept* concept, bool negated);
void createEquivalenceAbsorbedTriggeredImplication(CConcept* eqConcept, bool negated, CSortedNegLinker* absorpOpLinker);
CConcept* createDisjunctionAbsorbedTriggeredImplication(CConcept* orConcept, bool negated);
CConcept* createDisjunctionAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& candList);
void mergeDependingCacheList(QList** dependingCacheList, QList** subDependingCacheList);
CConceptTriggerLinker* getTriggersForConcept(CConcept* concept, bool negated, CConcept* backPropConcept = nullptr);
CConceptTriggerLinker* createTriggerLinker();
CConceptTriggerLinker* copyTriggerLinkers(CConceptTriggerLinker* triggers);
void releaseTriggerLinkers(CConceptTriggerLinker* triggers);
CDatatypeValueSpaceConceptTriggerLinker* createValueSpaceConceptTriggerLinker();
CConcept* getImplicationImpliedConcept(CConcept* implicationConcept);
CConceptTriggerLinker* getImplicationTriggeredConceptForTriggers(CConceptTriggerLinker* triggers, CConcept** firstImplicationConcept);
CConceptTriggerLinker* getUpdatedTriggerComplexities(CConceptTriggerLinker* triggers);
bool findAndReplaceImplicationFromTriggers(CConceptTriggerLinker* trigger, CConceptTriggerLinker*& otherTriggers);
CConcept* createTriggerConcept(bool branchTrigger = false);
CConcept* createMarkerConcept();
void addUnfoldingConceptForConcept(CConcept* concept, CConcept* addingUnfoldingConcept, bool addingNegation);
void addUnfoldingConceptForImplicationConcept(CConcept* implicationConcept, CConcept* addingUnfoldingConcept, bool addingNegation);
CConceptTriggerLinker* getPartialTriggersForConcept(CConcept* concept, bool negated, CConcept* backPropConcept = nullptr);
CConceptRoleBranchingTrigger* getSimpleBranchTriggersForConcept(CConcept* concept, bool negated);
CConceptRoleBranchingTrigger* getBranchTiggers(CConceptTriggerLinker* triggers);
CRole* getInverseRole(CRole* role);
bool isDisjunctionConceptTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated);
bool isDisjunctionConceptSimpleTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated);
bool isDisjunctionConceptPartialTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated);
bool isConceptPartialImplicationTriggerable(CConcept* concept, bool negated, QSet* conceptEqConAbsorbed);
bool isConceptAssuringImplicationTriggerable(CConcept* concept, bool negated, QSet* conceptEqConAbsorbed);
CConceptTriggerLinker* getAssuringTriggersForConcept(CConcept* concept, bool negated);
bool isCardinalityConceptQualificationTriggerAbsorbable(CConcept* cardConcept, bool negated);
bool isCardinalityConceptPartialQualificationTriggerAbsorbable(CConcept* cardConcept, bool negated);
CConceptRoleBranchingTrigger* createCardinalityQualificationPartialAbsorbedTriggers(CConcept* cardConcept, bool negated);
bool absorbGCIConceptsToTriggeredImplications(CConcept* orConcept, bool negated);
void createGCIAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& candList);
bool absorbPartialGCIConceptsToTriggeredImplications(CConcept* orConcept, bool negated);
void createGCIPartialAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, const QList& absorbList);
void createGCIAssuringAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, const QList& absorbList, const QList& disjList);
CConceptTriggerLinker* createAssuringExtendedAbsorbedImpliedTrigger(const QList& absorbList);
CConceptRoleBranchingTrigger* createDisjunctionPartialAbsorbedBranchTriggers(CConcept* orConcept, bool negated);
CConceptRoleBranchingTrigger* createDisjunctionPartialAbsorbedBranchTriggers(CConcept* orConcept, bool negated, const QList& absorbList);
bool createConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension = false);
bool createDirectConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension = false);
bool createPropagationConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension = false);
CConcept* getConceptOfInterestTrigger(CConcept* intConcept, bool negated, CConcept* backPropTriggerCon);
CConcept* getConceptOfInterestCandidate(CConcept* intConcept, bool negated, CConcept* backPropTriggerCon);
CConceptTriggerLinker* createBackpropPartialExtendedAbsorbedImpliedTrigger(const QList& absorbList, CConcept* backPropTriggerCon);
CConceptTriggerLinker* createBackpropExtendedAbsorbedImpliedTrigger(const QList& absorbList, CConcept* backPropTriggerCon);
CConcept* createDisjunctionAbsorbedBackpropagationTriggeredImplication(CConcept* orConcept, bool negated, CConcept* backPropTriggerCon);
CConcept* createDisjunctionAbsorbedBackpropagationTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& partialAbsorbList, QList& candList, CConcept* backPropTriggerCon);
CConcept* createPartialBackpropagationExtendedAbsorbedImpliedTriggerCocnept(const QList& absorbList, CConcept* backPropTriggerCon);
CConceptTriggerLinker* createPartialBackpropagationExtendedAbsorbedImpliedTrigger(const QList& absorbList, CConcept* backPropTriggerCon);
CConcept* createPartialExtendedAbsorbedTriggeredImplication(CConcept* impliedConcept, bool impliedNegation, const QList& absorbList);
CConcept* createPartialExtendedAbsorbedImpliedTriggerCocnept(const QList& absorbList);
CConceptTriggerLinker* createPartialExtendedAbsorbedImpliedTrigger(const QList& absorbList);
bool addAbsorbableDisjunctCandidates(CConcept* orConcept, bool negated, QList& list);
QList splitAbsorbableDisjuncts(QList& list);
QList getPartialAbsorbableDisjuncts(QList& list);
QList getAssuringAbsorbableDisjuncts(QList& list);
QString generateDebugGCIConceptString(CConcept* concept, bool conceptNegation);
QString generateDebugGeneratedAbsorbedImplicationString(cint64 minNewConceptTag, cint64 lastNewConceptTag);
void optimizeTriggerStructure();
void replaceTrigger(CConcept* baseConcept, CConcept* replaceConcept, bool negated);
void replaceOneTrigger(CConcept* baseConcept, CConcept* replaceConcept, bool negated);
bool absorbNominalConceptsToAssertions(CConcept* concept, bool negated);
bool absorbNegatedSelfToRoleDomain(CConcept* concept, bool negated);
bool absorbNominalSchemaGCIConceptsToTriggeredImplications(CConcept* concept, bool negated);
void createGCINominalSchemaAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& partialAbsorbList, QList& candList, CNominalSchemaTemplate* nsTemplate);
CNominalSchemaAbsorptionPathLinker* getAbsorbedNominalSchemaPaths(const QSet& conceptSet, CNominalSchemaAbsorptionPathLinker* absorptionPathLinker, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate);
void collectNominalSchemaRelatedConcepts(CConcept* concept, bool negated, QSet& conceptSet, CNominalSchemaTemplate* nsTemplate);
void sortNominalSchemaRelatedConcepts(QSet& conceptSet, CNominalSchemaTemplate* nsTemplate, QList& nomSchConList, QList& otherConList, QList& orConList);
CConcept* createBindingImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept);
CConcept* createBindingCycleCloseConcept(CConcept* cycleCloseTriggerConcept, CConcept* impliedTriggerConcept);
CConcept* createBindingTriggerConcept();
CConcept* createBindingVariableConcept(CConcept* followingConcept, CVariable* variable);
CConcept* createBindingToSuccessorPropagationConcept(CConcept* followingConcept, CRole* role);
CConcept* createBindingFromSuccessorPropagationConcept(CConcept* followingConcept, CRole* role);
CConcept* createBindingGroundingConcept(CNominalSchemaTemplate* nsTemplate, cint64 groundOpCode);
void createBindingGroundConcept(CConcept*& groundingConcept, bool& groundingConNegation, const QList& groundConceptList, CNominalSchemaTemplate* nsTemplate, cint64 groundOpCode);
CNominalSchemaAbsorptionPathLinker* duplicateNominalSchemaAbsorptionPaths(CNominalSchemaAbsorptionPathLinker* abPathLinker, cint64 duplicateCount);
CNominalSchemaAbsorptionBranchLinker* getAbsorbedJoinedNominalSchemaBranchLinker(CConcept* absorbingConcept, bool absorbingNegation, CConcept* backPropConTrigger, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate);
CNominalSchemaAbsorptionBranchLinker* getAbsorbedJoinedNominalSchemaBranchLinker(const QSet& conceptSet, CConcept* backPropConTrigger, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate);
CNominalSchemaAbsorptionBranchLinker* getAbsorbedNominalSchemaBranchLinker(CConcept* absorbingConcept, bool absorbingNegation, CConcept* backPropConTrigger, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate);
CConcept* createBindingBackPropagationActivationTriggerConcept();
CConcept* createBindingBackPropagationTriggerConcept();
CConcept* createBindingBackPropagationImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept);
bool addBindingBackPropagationTriggeredToImplicationConcept(CConcept* implicationConcept, CConcept* triggeredConcept);
CConcept* createBindingBackPropagationToSuccessorConcept(CConcept* followingConcept, CRole* role);
CConcept* createVariableBindingPropagationFromSuccessorConcept(CConcept* followingConcept, CRole* role);
CConcept* createVariableBindingPropagationTriggerConcept();
CConcept* createVariableBindingPropagationJoiningConcept(CConcept* joinConcept1, CConcept* joinConcept2, CConcept* impliedConcept);
CConcept* createVariableBindingPropagationBindVariableConcept(CConcept* followingConcept, CVariable* variable);
CConcept* createVariableBindingPropagationImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept);
void createJoiningConceptVariableList(CConcept* joiningConcept, CNominalSchemaAbsorptionBranchLinker* abLinker1, CNominalSchemaAbsorptionBranchLinker* abLinker2);
void addConceptOperand(CConcept* concept, CConcept* operandConcept, bool operandNegation);
bool hasNominalSchemaAbsorbableConceptFillHash(CConcept* concept, bool negation, CBOXHASH* absorbableConceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet* testedConceptSet);
bool hasNominalSchemaConceptFillHash(CConcept* concept, CBOXHASH* conceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet* testedConceptSet);
void collectNominalSchemaConcepts(CConcept* concept, CBOXSET* nominalSchemaConceptSet);
bool isConceptPropagationTriggerable(CConcept* concept, bool negated);
CConceptTriggerLinker* getPropagationTriggersForConcept(CConcept* concept, bool negated, TConceptNegPair& intConceptNegationPair, bool completelyAbsorbable);
CConceptTriggerLinker* getPropagationTriggersForConceptOperandList(CSortedNegLinker* opConLinker, bool operandsNegation, bool chooseInsteadOfNegation, CConcept* concept, bool negated, TConceptNegPair& intConceptNegationPair, bool completelyAbsorbable);
// protected variables
protected:
class CAbsorpEquivalentClassItem {
public:
CAbsorpEquivalentClassItem(CConcept* eqConcept, CSortedNegLinker* absorpOpLinker) {
mEqConcept = eqConcept;
mAbsorpOpLinker = absorpOpLinker;
}
CConcept* mEqConcept;
CSortedNegLinker* mAbsorpOpLinker;
};
CMemoryAllocationManager* mMemMan;
CMBox* mMBox;
CTBox* mTBox;
QHash mConceptImplicationImpliedHash;
QHash mConceptTriggerLinkerHash;
QHash mAssuringConceptTriggerLinkerHash;
CConceptTriggerLinker* mTmpTriggerLinker;
QHash mBackPropActivationConHash;
QSet mCreatedImpliedDisjunctions;
QList mTriggerContainer;
QList*> mLaterTopConceptTriggerAddList;
QHash mConceptTriggerHash;
QHash mTriggerCountHash;
CConceptVector* mConceptVec;
CConcept* mBottomConcept;
CConcept* mTopConcept;
CConcreteOntology* mOnto;
CBranchingTriggerVector* mBranchTriggVec;
CNominalSchemaTemplateVector* mNomSchemaTemplVec;
CBOXHASH* mTriggerImplHash;
QHash mConceptTotalAbsorbableHash;
QHash mConceptPartialAbsorbableHash;
QHash mConceptAssuringAbsorbableHash;
QSet mEQNotConceptPartialAbsorbableSet;
QHash mConceptPropagationAbsorbableHash;
CBOXHASH* mEquivConCandidateHash;
CBOXHASH* mCandidateEquivConHash;
CBOXSET* mEquivConNonCandidateSet;
QHash* mRoleDomainTriggerConceptHash;
QHash mConceptNomSchAbsorpBranchLinkerHash;
QHash mAbsorptionBranchPairAbsorptionBranchHash;
QHash mRoleInverseRoleCreateHash;
CBOXHASH* mIndividualTriggerConceptHash;
QSet mPositiveConceptReferencedSet;
CImplicationReplacementVector* mImpRepVec = nullptr;
cint64 mNextVariableID;
bool mConfRequiresExistingInverseRole;
bool mConfAbsorbEqClassDefinitions;
bool mConfPartialAbsorbEqClassDefinitions;
bool mConfPartialGCIAbsorption;
bool mConfAbsorbDisjunctions;
bool mConfAbsorbSimpleDisjunctions;
bool mConfPartialDisjunctionsAbsorption;
bool mConfOnlyPositiveDisjunctionsAbsorption;
bool mConfCardinalityQualificationTriggerAbsorption;
bool mConfPartialCardinalityQualificationTriggerAbsorption;
bool mConfOnlyPositiveCardinalityQualificationTriggerAbsorption;
bool mConfGlobalNegatedSelfRestrictionsToRoleDomainAbsorption;
bool mConfNominalSchemaPathPreabsorption;
bool mConfVariableMultipleTriggeredBackwardChainingAbsorption;
bool mConfNominalSchemaBackPropagation;
bool mConfNominalSchemaBackPropagationMultiTrigger;
bool mConfImplicationsForTriggerReusue;
bool mConfPunishOftenSameTriggerUse;
cint64 mConfOftenTriggerUseCountPunishment;
bool mConfDatatypeAbsorption;
class CTriggCount {
public:
inline CTriggCount() {
mCount = 0;
}
inline void incCount(cint64 count = 1) {
mCount += count;
}
cint64 mCount;
};
QHash mTriggCountHash;
class CBackPropTrigHashData {
public:
inline CBackPropTrigHashData(CConcept* activationTriggerConcept, CConcept* implicationConcept) {
mActivationTriggerConcept = activationTriggerConcept;
mImplicationConcept = implicationConcept;
}
CConcept* mActivationTriggerConcept;
CConcept* mImplicationConcept;
};
QHash mVarBackPropTrigHash;
QList mVarBackPropTrigContainer;
cint64 mStatInvRolesGenerated;
cint64 mStatGCIAbsorbed;
cint64 mStatGCINormalAbsorbed;
cint64 mStatGCIPartialAbsorbed;
cint64 mStatGCIAbsorptionPartialExtended;
cint64 mStatGCIAbsorptionAssuring;
cint64 mStatGCITotal;
cint64 mStatEqAbsorbed;
cint64 mStatEqTotal;
cint64 mStatImplConceptsGenerated;
cint64 mStatReusedImplications;
cint64 mStatOptimizedRemovedTriggers;
cint64 mStatGCINormalSchemaAbsorbed;
cint64 mStatGCIAssertionAbsorbed;
QString mDebugGCIString;
QString mDebugAbsorbedString;
QString mDebugLastGCIString;
QString mDebugLastAbsorbedGCIConceptString;
QString mDebugLastAbsorbedGCITechniqueString;
QString mDebugLastAbsorbedGCIString;
QString mDebugTotalAbsorbedGCIString;
cint64 mLastNewConceptTag;
cint64 mFirstNewConceptTag;
cint64 mLastDisjunctId;
// private methods
private:
// private variables
private:
};
}; // end namespace Preprocess
}; // end namespace Reasoner
}; // end namespace Konclude
#endif // KONCLUDE_REASONER_PREPROCESS_CTRIGGEREDIMPLICATIONBINARYABSORBERPREPROCESS_H