/* * 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 "CSubroleTransformationPreProcess.h" namespace Konclude { namespace Reasoner { namespace Preprocess { CSubroleTransformationPreProcess::CSubroleTransformationPreProcess() { } CSubroleTransformationPreProcess::~CSubroleTransformationPreProcess() { } CConcreteOntology *CSubroleTransformationPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) { mOntology = ontology; if (ontology) { mTBox = ontology->getDataBoxes()->getTBox(); mABox = ontology->getDataBoxes()->getABox(); mRBox = ontology->getDataBoxes()->getRBox(); mMBox = ontology->getDataBoxes()->getMBox(); mRolesVector = mRBox->getRoleVector(); mConceptVector = mTBox->getConceptVector(); mIndiVec = mABox->getIndividualVector(); mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); mTopObjectRole = nullptr; mBottomObjectRole = nullptr; mTopDataRole = nullptr; mBottomDataRole = nullptr; QSet mProcessedRoleSet; QSet locRoleTagSet; QList subRoleUpdateTagList; COntologyBuildConstructFlags* construcFlags = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags(); bool topObjectRuleUsed = construcFlags->isTopObjectRoleUsed(); bool bottomObjectRuleUsed = construcFlags->isBottomObjectRoleUsed(); bool confForceInverseRoleCreation = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Preprocessing.ForceInverseRoleCreation",true); bool confComplexQueryingSupport = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Querying.ComplexQueryingSupport",true); if (topObjectRuleUsed || confComplexQueryingSupport) { mRoleChainVector = mRBox->getRoleChainVector(); makeUniversalSuperRole(); } if (bottomObjectRuleUsed) { makeBottomObjectRoleDomain(); } bool topDataRuleUsed = construcFlags->isTopDataRoleUsed(); bool bottomDataRuleUsed = construcFlags->isBottomDataRoleUsed(); if (topDataRuleUsed) { makeDataSuperRole(); } if (bottomDataRuleUsed) { makeBottomDataRoleDomain(); } CBUILDHASH* roleObjPropTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash(); CBUILDHASH* objPropTermRoleHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash(); CBUILDLIST* expressionBuildContainerList = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getExpressionBuildListContainer(); CBUILDHASH* expressionBuildHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getStructuralExpressionBuildHash(); qint64 itemCounts = mRolesVector->getItemCount(); for (qint64 i = 0; i < itemCounts; ++i) { CRole *role = mRolesVector->getLocalData(i); if (role) { if (!role->getInverseRole() && !role->isDataRole()) { for (CSortedNegLinker* inverseEquivalentRolesIt = role->getInverseEquivalentRoleList(); inverseEquivalentRolesIt && !role->getInverseRole(); inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext()) { if (inverseEquivalentRolesIt->isNegated()) { role->setInverseRole(inverseEquivalentRolesIt->getData()); } } } if ((confForceInverseRoleCreation || confComplexQueryingSupport) && !role->hasInverseRoles()) { CRole* inverseRole = CObjectAllocator< CRole >::allocateAndConstruct(mMemMan); inverseRole->initRole(); inverseRole->setInverseRole(role); inverseRole->setDataRole(role->isDataRole()); cint64 inverseRoleTag = mRolesVector->getItemCount(); inverseRole->setRoleTag(inverseRoleTag); inverseRole->setRoleComplexity(role->getRoleComplexity()); mRolesVector->setData(inverseRole->getRoleTag(), inverseRole); CSortedNegLinker* invRoleLinker1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); invRoleLinker1->init(role, true); inverseRole->addSuperRoleLinker(invRoleLinker1); CSortedNegLinker* invRoleLinker2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); invRoleLinker2->init(inverseRole, true); role->addSuperRoleLinker(invRoleLinker2); role->setInverseRole(inverseRole); CSortedNegLinker* invEqRoleLinker1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); invEqRoleLinker1->init(role, true); inverseRole->addEquivalentRoleLinker(invEqRoleLinker1); CSortedNegLinker* invEqRoleLinker2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); invEqRoleLinker2->init(inverseRole, true); role->addEquivalentRoleLinker(invEqRoleLinker2); if (mTopObjectRole && (topObjectRuleUsed || confComplexQueryingSupport) && !role->isDataRole()) { CSortedNegLinker* invUnivRoleSuperLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); invUnivRoleSuperLinker->init(mTopObjectRole, true); inverseRole->addSuperRoleLinker(invUnivRoleSuperLinker); } if (!role->isDataRole()) { CObjectPropertyTermExpression* buildExpression = roleObjPropTermHash->value(role); CInverseObjectPropertyOfExpression* invRoleExpression = new CInverseObjectPropertyOfExpression(buildExpression); expressionBuildHash->insert(CExpressionHasher(invRoleExpression), invRoleExpression); expressionBuildContainerList->append(invRoleExpression); roleObjPropTermHash->insert(role, invRoleExpression); objPropTermRoleHash->insert(invRoleExpression, role); } } } } itemCounts = mRolesVector->getItemCount(); for (qint64 i = 0; i < itemCounts; ++i) { CRole *role = mRolesVector->getLocalData(i); if (role) { locRoleTagSet.insert(role->getRoleTag()); subRoleUpdateTagList.append(role->getRoleTag()); if (!mProcessedRoleSet.contains(role)) { // update all direct super roles QSet< QPair > inEqRoleSet; collectInverseEquivalentRoles(role,false,&inEqRoleSet); for (QSet< QPair >::const_iterator it = inEqRoleSet.constBegin(), itEnd = inEqRoleSet.constEnd(); it != itEnd; ++it) { QPair roleNegPair(*it); CRole* upRole = roleNegPair.first; bool upNeg = roleNegPair.second; if (!mProcessedRoleSet.contains(upRole)) { mProcessedRoleSet.insert(upRole); updateDirectSuperRoles(upRole,upNeg,&inEqRoleSet); } } } } } QHash roleTagSubRoleTagHash; for (qint64 i = 0; i < itemCounts; ++i) { CRole *role = mRolesVector->getLocalData(i); if (role) { cint64 roleTag = role->getRoleTag(); CSortedNegLinker* superRoleLinkerIt = role->getSuperRoleList(); while (superRoleLinkerIt) { CRole* superRole = superRoleLinkerIt->getData(); cint64 superRoleTag = superRole->getRoleTag(); roleTagSubRoleTagHash.insertMulti(superRoleTag,roleTag); superRoleLinkerIt = superRoleLinkerIt->getNext(); } } } FOREACHIT (cint64 locRoleTag, locRoleTagSet) { FOREACHIT (cint64 subRoleTag, roleTagSubRoleTagHash.values(locRoleTag)) { if (!locRoleTagSet.contains(subRoleTag)) { locRoleTagSet.insert(subRoleTag); subRoleUpdateTagList.append(subRoleTag); } } } while (!subRoleUpdateTagList.isEmpty()) { cint64 updateTag = subRoleUpdateTagList.takeFirst(); CRole *role = mRolesVector->getData(updateTag); role = getLocalizedRole(role); if (role) { // update indirect super role list QSet< QPair > singleSuperRoleAddSet; singleSuperRoleAddSet.insert(QPair(role,false)); CSortedNegLinker *superRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); superRoleLinker->init(role,false); role->setIndirectSuperRoleLinker(superRoleLinker); addIndirectSuperRoles(false,role,role->getSuperRoleList(),&singleSuperRoleAddSet); FOREACHIT (cint64 subRoleTag, roleTagSubRoleTagHash.values(updateTag)) { if (!locRoleTagSet.contains(subRoleTag)) { locRoleTagSet.insert(subRoleTag); subRoleUpdateTagList.append(subRoleTag); } } } } for (qint64 i = 0; i < itemCounts; ++i) { CRole *role = mRolesVector->getLocalData(i); if (role) { if (role->getRoleChainSuperSharingLinker() != nullptr) { role->setRoleComplexity(true); // all super roles must be complex, too CSortedNegLinker* superRoleLinkerIt = role->getIndirectSuperRoleList(); while (superRoleLinkerIt) { CRole* superRole = superRoleLinkerIt->getData(); if (!superRole->isComplexRole()) { superRole = getLocalizedRole(superRole); superRole->setRoleComplexity(true); } superRoleLinkerIt = superRoleLinkerIt->getNext(); } } } } if (topObjectRuleUsed && mABox->getIndividualCount() > 0 && hasUniversalRolePropagation()) { makeUniversalConnectionIndividual(); } } cint64 conCount = mConceptVector->getItemCount(); mLastConceptId = conCount; return ontology; } CConcreteOntology* CSubroleTransformationPreProcess::continuePreprocessing() { cint64 conCount = mConceptVector->getItemCount(); if (!mABox->hasUniversalConnectionIndividual()) { for (qint64 i = mLastConceptId; i < conCount && !mABox->hasUniversalConnectionIndividual(); ++i) { CConcept *concept = mConceptVector->getLocalData(i); if (concept) { cint64 opCode = concept->getOperatorCode(); if (opCode == CCALL || opCode == CCSOME || opCode == CCIMPLALL || opCode == CCBRANCHALL || opCode == CCVARBINDALL || opCode == CCPBINDALL || opCode == CCVARPBACKALL) { CRole* role = concept->getRole(); if (role->getRoleTag() == 1) { makeUniversalConnectionIndividual(); } } } } } mLastConceptId = conCount; return mOntology; } void CSubroleTransformationPreProcess::makeUniversalConnectionIndividual() { cint64 univConnIndiID = 0; CIndividual* universalConnIndi = nullptr; CConcept* universalConnNominalValueCon = nullptr; CConcept* universalConnNominalCon = nullptr; if (!mABox->hasUniversalConnectionIndividual()) { univConnIndiID = mABox->getNextIndividualId(); mABox->setUniversalConnectionIndividualID(univConnIndiID); mABox->setHasUniversalConnectionIndividual(true); universalConnIndi = CObjectAllocator< CIndividual >::allocateAndConstruct(mMemMan); universalConnIndi->initIndividual(univConnIndiID); universalConnIndi->setFakeIndividual(true); mIndiVec->setData(univConnIndiID, universalConnIndi); cint64 valueConTag = mTBox->getNextConceptID(); universalConnNominalValueCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); universalConnNominalValueCon->initConcept(); universalConnNominalValueCon->setConceptTag(valueConTag); universalConnNominalValueCon->setOperatorCode(CCVALUE); universalConnNominalValueCon->setNominalIndividual(universalConnIndi); universalConnNominalValueCon->setRole(mRolesVector->getData(1)); mConceptVector->setData(valueConTag,universalConnNominalValueCon); mTBox->setUniversalConnectionNominalValueConcept(universalConnNominalValueCon); cint64 nominalConTag = mTBox->getNextConceptID(); universalConnNominalCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); universalConnNominalCon->initConcept(); universalConnNominalCon->setConceptTag(nominalConTag); universalConnNominalCon->setOperatorCode(CCNOMINAL); universalConnNominalCon->setNominalIndividual(universalConnIndi); mConceptVector->setData(nominalConTag,universalConnNominalCon); universalConnIndi->setIndividualNominalConcept(universalConnNominalCon); } } void CSubroleTransformationPreProcess::makeBottomObjectRoleDomain() { mBottomObjectRole = mRolesVector->getData(mRBox->getBottomObjectRoleIndex()); makeBottomRoleDomain(mBottomObjectRole); } void CSubroleTransformationPreProcess::makeBottomDataRoleDomain() { mBottomDataRole = mRolesVector->getData(mRBox->getBottomDataRoleIndex()); makeBottomRoleDomain(mBottomDataRole); } void CSubroleTransformationPreProcess::makeBottomRoleDomain(CRole* role) { bool foundBottom = false; for (CSortedNegLinker* domainConIt = role->getDomainConceptList(); !foundBottom && domainConIt; domainConIt = domainConIt->getNext()) { CConcept* domainConcept = domainConIt->getData(); bool domainConNegation = domainConIt->isNegated(); if (domainConNegation && domainConcept->getOperatorCode() == CCTOP) { foundBottom = true; } else if (!domainConNegation && domainConcept->getOperatorCode() == CCBOTTOM) { foundBottom = true; } } if (!foundBottom) { role = getLocalizedRole(role); CSortedNegLinker* domainConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); domainConLinker->init(mTBox->getTopConcept(),true); role->addDomainConceptLinker(domainConLinker); } } void CSubroleTransformationPreProcess::makeUniversalSuperRole() { mOntology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->setComplexRoleUsed(); bool topRoleLocalized = false; mTopObjectRole = mRolesVector->getData(mRBox->getTopObjectRoleIndex(), &topRoleLocalized); if (!mTopObjectRole->isTransitive()) { if (!topRoleLocalized) { topRoleLocalized = true; mTopObjectRole = getLocalizedRole(mTopObjectRole); } mTopObjectRole->setTransitive(true); cint64 roleChainCount = mRoleChainVector->getItemCount(); CRoleChain* roleChain = CObjectAllocator< CRoleChain >::allocateAndConstruct(mMemMan); roleChain->initRoleChain(); CXLinker* roleLinker1 = CObjectAllocator< CXLinker >::allocateAndConstruct(mMemMan); CXLinker* roleLinker2 = CObjectAllocator< CXLinker >::allocateAndConstruct(mMemMan); roleLinker1->initLinker(mTopObjectRole); roleLinker2->initLinker(mTopObjectRole); roleChain->appendRoleChainLinker(roleLinker1); roleChain->appendRoleChainLinker(roleLinker2); roleChain->initTag(roleChainCount); mRoleChainVector->setData(roleChainCount,roleChain); CXLinker* superRoleChainLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(mMemMan); superRoleChainLinker->initLinker(roleChain); mTopObjectRole->addRoleChainSuperSharingLinker(superRoleChainLinker); CXLinker* subRoleChainLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(mMemMan); subRoleChainLinker->initLinker(roleChain); mTopObjectRole->addRoleChainSubSharingLinker(subRoleChainLinker); } if (!mTopObjectRole->isSymmetric()) { if (!topRoleLocalized) { topRoleLocalized = true; mTopObjectRole = getLocalizedRole(mRolesVector->getData(mRBox->getTopObjectRoleIndex())); } mTopObjectRole->setSymmetric(true); CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); roleLinker->init(mTopObjectRole,true); mTopObjectRole->addInverseRoleLinker(roleLinker); } cint64 roleCount = mRolesVector->getItemCount(); for (cint64 roleIdx = 1; roleIdx < roleCount; ++roleIdx) { CRole* role = mRolesVector->getData(roleIdx); if (role && role->isObjectRole() && !role->hasSuperRoleTag(mTopObjectRole->getRoleTag())) { role = getLocalizedRole(role); CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); roleLinker->init(mTopObjectRole,true); role->addSuperRoleLinker(roleLinker); } } // make reflexive -> add \exists u.SELF to TOP bool topConLocal = false; CConcept* topConcept = mConceptVector->getData(1,&topConLocal); bool hasTopExistsUniversalSelf = false; bool renewTopExistsUniversalSelf = false; CConcept* existsUniversalSelfConcept = nullptr; for (CSortedNegLinker* opLinker = topConcept->getOperandList(); !hasTopExistsUniversalSelf && opLinker; opLinker = opLinker->getNext()) { if (!opLinker->isNegated()) { CConcept* opConcept = opLinker->getData(); if (opConcept->getOperatorCode() == CCSELF && opConcept->getRole()->getRoleTag() == mTopObjectRole->getRoleTag()) { hasTopExistsUniversalSelf = true; existsUniversalSelfConcept = opConcept; if (opConcept->getRole() != mTopObjectRole) { renewTopExistsUniversalSelf = true; } } } } if (!hasTopExistsUniversalSelf) { if (!topConLocal) { topConcept = CConceptRoleIndividualLocator::getLocatedConcept(topConcept, mOntology); } CConcept* univSelfCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); cint64 conCount = mTBox->getNextConceptID(); univSelfCon->initConcept(); univSelfCon->setConceptTag(conCount); univSelfCon->setRole(mTopObjectRole); univSelfCon->setOperatorCode(CCSELF); mConceptVector->setData(conCount,univSelfCon); CSortedNegLinker* topOpLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); topOpLinker->init(univSelfCon,false); topConcept->addOperandLinker(topOpLinker); topConcept->incOperandCount(1); } else if (renewTopExistsUniversalSelf) { if (!topConLocal) { topConcept = CConceptRoleIndividualLocator::getLocatedConcept(topConcept, mOntology); } CConcept* univSelfCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); cint64 conCount = mTBox->getNextConceptID(); univSelfCon->initConcept(); univSelfCon->setConceptTag(conCount); univSelfCon->setRole(mTopObjectRole); univSelfCon->setOperatorCode(CCSELF); mConceptVector->setData(conCount, univSelfCon); bool replaced = false; for (CSortedNegLinker* opLinker = topConcept->getOperandList(); !replaced && opLinker; opLinker = opLinker->getNext()) { if (opLinker->getData() == existsUniversalSelfConcept) { opLinker->setData(univSelfCon); replaced = true; } } } } void CSubroleTransformationPreProcess::makeDataSuperRole() { mTopDataRole = getLocalizedRole(mRolesVector->getData(mRBox->getTopDataRoleIndex())); cint64 roleCount = mRolesVector->getItemCount(); for (cint64 roleIdx = 0; roleIdx < roleCount; ++roleIdx) { CRole* role = mRolesVector->getData(roleIdx); if (role && role->isDataRole() && !role->hasSuperRoleTag(mTopDataRole->getRoleTag())) { role = getLocalizedRole(role); CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); roleLinker->init(mTopDataRole,true); role->addSuperRoleLinker(roleLinker); } } } CIndividual* CSubroleTransformationPreProcess::getLocalizedIndividual(CIndividual* individual) { cint64 indiID = individual->getIndividualID(); if (!mIndiVec->hasLocalData(indiID)) { individual = CConceptRoleIndividualLocator::getLocatedIndividual(mIndiVec->getLocalData(indiID),mOntology); } else { individual = mIndiVec->getLocalData(indiID); } return individual; } CRole* CSubroleTransformationPreProcess::getLocalizedRole(CRole* role) { cint64 roleTag = role->getRoleTag(); if (!mRolesVector->hasLocalData(roleTag)) { role = CConceptRoleIndividualLocator::getLocatedRole(role,mOntology); } else { role = mRolesVector->getLocalData(roleTag); } return role; } CSubroleTransformationPreProcess* CSubroleTransformationPreProcess::updateDirectSuperRoles(CRole* role, bool negated, QSet< QPair >* roleSet) { role = getLocalizedRole(role); for (QSet< QPair >::const_iterator it = roleSet->constBegin(), itEnd = roleSet->constEnd(); it != itEnd; ++it) { QPair roleNegPair(*it); CRole* upRole = roleNegPair.first; bool upNeg = roleNegPair.second^negated; cint64 upRoleTag = upRole->getRoleTag(); if (upRole != role || upNeg) { if (!role->hasSuperRoleTag(upRoleTag,upNeg)) { CSortedNegLinker* superRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); superRoleLinker->init(upRole,upNeg); role->addSuperRoleLinker(superRoleLinker); } } } return this; } CSubroleTransformationPreProcess* CSubroleTransformationPreProcess::collectInverseEquivalentRoles(CRole* role, bool negated, QSet< QPair >* roleSet) { if (!roleSet->contains(QPair(role,negated))) { roleSet->insert(QPair(role,negated)); CSortedNegLinker* inEqRoleLinker = role->getInverseEquivalentRoleList(); while (inEqRoleLinker) { CRole* inEqRole = inEqRoleLinker->getData(); inEqRole = mRolesVector->getData(inEqRole->getRoleTag()); bool inEqRoleNeg = inEqRoleLinker->isNegated(); collectInverseEquivalentRoles(inEqRole,inEqRoleNeg^negated,roleSet); inEqRoleLinker = inEqRoleLinker->getNext(); } } return this; } bool CSubroleTransformationPreProcess::hasUniversalRolePropagation() { QSet topSuperRoleSet; topSuperRoleSet.insert(mTopObjectRole); for (CSortedNegLinker* topSuperRoleIt = mTopObjectRole->getIndirectSuperRoleList(); topSuperRoleIt; topSuperRoleIt = topSuperRoleIt->getNext()) { CRole* topSuperRole = topSuperRoleIt->getData(); topSuperRoleSet.insert(topSuperRole); } cint64 conCount = mConceptVector->getItemCount(); for (cint64 conIdx = 0; conIdx < conCount; ++conIdx) { CConcept* concept = mConceptVector->getData(conIdx); if (concept && concept->getOperatorCode() != CCSELF) { CRole* role = concept->getRole(); if (role && topSuperRoleSet.contains(role)) { return true; } } } return false; } void CSubroleTransformationPreProcess::addIndirectSuperRoles(bool inverse, CRole *modifingSubRole, CSortedNegLinker *superRoleLinker, QSet< QPair > *singleSuperRoleAddSet) { CSortedNegLinker *superRoleIt = superRoleLinker; while (superRoleIt) { CRole *superRole = superRoleIt->getData(); superRole = mRolesVector->getData(superRole->getRoleTag()); bool inversed = superRoleIt->isNegated()^inverse; if (!singleSuperRoleAddSet->contains(QPair(superRole,inversed))) { singleSuperRoleAddSet->insert(QPair(superRole,inversed)); CSortedNegLinker *nextSuperRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); nextSuperRoleLinker->init(superRole,inversed); modifingSubRole->addIndirectSuperRoleLinker(nextSuperRoleLinker); addIndirectSuperRoles(inversed,modifingSubRole,superRole->getSuperRoleList(),singleSuperRoleAddSet); } superRoleIt = (CSortedNegLinker *)superRoleIt->getNext(); } } }; // end namespace Preprocess }; // end namespace Reasoner }; // end namespace Konclude