/* * 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 "CFullNominalSchemaGroundingPreProcess.h" namespace Konclude { namespace Reasoner { namespace Preprocess { CFullNominalSchemaGroundingPreProcess::CFullNominalSchemaGroundingPreProcess() { mConfReuseGroundedNominalSchemaConcepts = true; mConfGroundNominalSchemaAbsorbableConcepts = false; mConfFullyGroundNominalSchemaConcepts = false; } CFullNominalSchemaGroundingPreProcess::~CFullNominalSchemaGroundingPreProcess() { } CConcreteOntology *CFullNominalSchemaGroundingPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) { bool nominalSchemaConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNominalSchemaUsed(); if (nominalSchemaConstructsUsed) { mStatReplacedConceptCount = 0; mStatCreatedConceptCount = 0; mStatGroundedTemplateCount = 0; mStatInstantiatedAxiomsCount = 0; mTBox = ontology->getDataBoxes()->getTBox(); CRBox *rBox = ontology->getDataBoxes()->getRBox(); CABox *aBox = ontology->getDataBoxes()->getABox(); mMBox = ontology->getDataBoxes()->getMBox(); CConfiguration* config = context->getConfiguration(); mConfGroundNominalSchemaAbsorbableConcepts = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.AbsorbableNominalSchemaGrounding",false); mConfFullyGroundNominalSchemaConcepts = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.FullNominalSchemaGrounding",false); mConfGroundNominalSchemaAbsorbableConcepts |= mConfFullyGroundNominalSchemaConcepts; mConceptVec = mTBox->getConceptVector(); mConceptCount = mConceptVec->getItemCount(); mRolesVec = rBox->getRoleVector(); mRoleCount = mRolesVec->getItemCount(); mTopConcept = mTBox->getTopConcept(); mBottomConcept = mTBox->getBottomConcept(); mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); mOnto = ontology; mNomSchTemplVec = mMBox->getNominalSchemaTemplateVector(false); mIndividualVector = aBox->getIndividualVector(false); mIndividualCount = 0; if (mIndividualVector) { mIndividualCount = mIndividualVector->getItemCount(); // TODO: only active individuals for (cint64 i = 0; i < mIndividualCount; ++i) { CIndividual* individual = mIndividualVector->getData(i); if (individual) { for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) { CConcept* assCon = assConLinkerIt->getData(); bool assConNegation = assConLinkerIt->isNegated(); cint64 assConOpCode = assCon->getOperatorCode(); if (!assConNegation && assConOpCode == CCNOMINAL) { mNominalConceptSet.insert(assCon); } } } } } if (mNomSchTemplVec) { for (cint64 i = 0; i < mConceptCount; ++i) { CConcept* concept = mConceptVec->getLocalData(i); if (concept) { cint64 conOpCode = concept->getOperatorCode(); if (conOpCode == CCSUB) { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); bool opConNegation = opConLinkerIt->isNegated(); cint64 opConOpCode = opConcept->getOperatorCode(); if (opConOpCode == CCNOMTEMPLREF) { cint64 templNumber = opConcept->getParameter(); CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber); if (nsTemplate) { CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate); opConLinkerIt->setData(nomSchAxiomCollConcept); opConLinkerIt->setNegated(false); } } } } } } for (cint64 i = 0; i < mRoleCount; ++i) { CRole* role = mRolesVec->getLocalData(i); if (role) { for (CSortedNegLinker* domConLinkerIt = role->getDomainConceptList(); domConLinkerIt; domConLinkerIt = domConLinkerIt->getNext()) { CConcept* opConcept = domConLinkerIt->getData(); bool opConNegation = domConLinkerIt->isNegated(); cint64 opConOpCode = opConcept->getOperatorCode(); if (opConOpCode == CCNOMTEMPLREF) { cint64 templNumber = opConcept->getParameter(); CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber); if (nsTemplate) { CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate); domConLinkerIt->setData(nomSchAxiomCollConcept); domConLinkerIt->setNegated(false); } } } for (CSortedNegLinker* rangConLinkerIt = role->getRangeConceptList(); rangConLinkerIt; rangConLinkerIt = rangConLinkerIt->getNext()) { CConcept* opConcept = rangConLinkerIt->getData(); bool opConNegation = rangConLinkerIt->isNegated(); cint64 opConOpCode = opConcept->getOperatorCode(); if (opConOpCode == CCNOMTEMPLREF) { cint64 templNumber = opConcept->getParameter(); CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber); if (nsTemplate) { CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate); rangConLinkerIt->setData(nomSchAxiomCollConcept); rangConLinkerIt->setNegated(false); } } } } } for (CSortedNegLinker* gciConLinkerIt = mTopConcept->getOperandList(); gciConLinkerIt; gciConLinkerIt = gciConLinkerIt->getNext()) { CConcept* opConcept = gciConLinkerIt->getData(); bool opConNegation = gciConLinkerIt->isNegated(); cint64 opConOpCode = opConcept->getOperatorCode(); if (opConOpCode == CCNOMTEMPLREF) { cint64 templNumber = opConcept->getParameter(); CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber); if (nsTemplate && requiresGCIGrounding(nsTemplate,opConNegation)) { CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate); gciConLinkerIt->setData(nomSchAxiomCollConcept); gciConLinkerIt->setNegated(false); } } } if (mIndividualVector) { for (cint64 i = 0; i < mIndividualCount; ++i) { CIndividual* individual = mIndividualVector->getLocalData(i); if (individual) { for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) { CConcept* assCon = assConLinkerIt->getData(); bool assConNegation = assConLinkerIt->isNegated(); cint64 opConOpCode = assCon->getOperatorCode(); if (opConOpCode == CCNOMTEMPLREF) { cint64 templNumber = assCon->getParameter(); CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber); if (nsTemplate) { CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(assCon,assConNegation,nsTemplate); assConLinkerIt->setData(nomSchAxiomCollConcept); assConLinkerIt->setNegation(false); } } } } } } } LOG(INFO,"::Konclude::Reasoner::Preprocess::FullNominalSchemaGrounder",logTr("Grounded %1 nominal schema templates, added %2 axioms with %3 created concepts.").arg(mStatGroundedTemplateCount).arg(mStatInstantiatedAxiomsCount).arg(mStatCreatedConceptCount),this); } return ontology; } bool CFullNominalSchemaGroundingPreProcess::requiresGCIGrounding(CNominalSchemaTemplate* nsTemplate, bool negated) { CConcept* templConcept = nsTemplate->getTemplateConcept(); if (mReqGroundConHash.contains(QPair(templConcept,negated))) { return mReqGroundConHash.value(QPair(templConcept,negated)); } bool requiresGrounding = true; if (!mConfGroundNominalSchemaAbsorbableConcepts) { cint64 opCode = templConcept->getOperatorCode(); if (!negated && opCode == CCOR || negated && opCode == CCAND) { QSet absorbableNominalVariableSet; for (CSortedNegLinker* opLinkerIt = templConcept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) { CConcept* opConcept = opLinkerIt->getData(); bool opConNegation = opLinkerIt->isNegated() ^ negated; findAbsorbableNominalSchemas(opConcept,opConNegation,&absorbableNominalVariableSet); } bool absorbable = absorbableNominalVariableSet.count() > 0; requiresGrounding = !absorbable; } } mReqGroundConHash.insert(QPair(templConcept,negated),requiresGrounding); return requiresGrounding; } bool CFullNominalSchemaGroundingPreProcess::findAbsorbableNominalSchemas(CConcept* concept, bool negation, QSet* absorbableNominalVariableSet) { cint64 opCode = concept->getOperatorCode(); cint64 param = concept->getParameter(); if (negation && (opCode == CCSOME || opCode == CCAND) || !negation && (opCode == CCALL || opCode == CCSOME)) { bool oneAbsorbable = false; for (CSortedNegLinker* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) { CConcept* opConcept = opLinkerIt->getData(); bool opConNegation = opLinkerIt->isNegated() ^ negation; oneAbsorbable |= findAbsorbableNominalSchemas(opConcept,opConNegation,absorbableNominalVariableSet); } return oneAbsorbable; } else if (negation && (opCode == CCOR) || !negation && (opCode == CCAND)) { QSet allAbsorbableNominalVariableSet; bool allAbsorbableNominalVariableSetInitialized = false; bool allAbsorbable = true; for (CSortedNegLinker* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) { CConcept* opConcept = opLinkerIt->getData(); bool opConNegation = opLinkerIt->isNegated() ^ negation; QSet tmpAbsorbableNominalVariableSet; allAbsorbable &= findAbsorbableNominalSchemas(opConcept,opConNegation,&tmpAbsorbableNominalVariableSet); if (!allAbsorbableNominalVariableSetInitialized) { allAbsorbableNominalVariableSetInitialized = true; allAbsorbableNominalVariableSet = tmpAbsorbableNominalVariableSet; } else { QSet::iterator it = allAbsorbableNominalVariableSet.begin(); while (it != allAbsorbableNominalVariableSet.end()) { if (tmpAbsorbableNominalVariableSet.contains(*it)) { ++it; } else { it = allAbsorbableNominalVariableSet.erase(it); } } } } *absorbableNominalVariableSet += allAbsorbableNominalVariableSet; return allAbsorbable; } else if (negation && (opCode == CCATLEAST && param > 0) || !negation && (opCode == CCATMOST && param >= 0)) { bool oneAbsorbable = false; for (CSortedNegLinker* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) { CConcept* opConcept = opLinkerIt->getData(); bool opConNegation = opLinkerIt->isNegated(); oneAbsorbable |= findAbsorbableNominalSchemas(opConcept,opConNegation,absorbableNominalVariableSet); } return oneAbsorbable; } else if (negation && (opCode == CCNOMVAR)) { absorbableNominalVariableSet->insert(concept); return true; } return false; } void CFullNominalSchemaGroundingPreProcess::addConceptOperand(CConcept* concept, CConcept* opConcept, bool negated) { CSortedNegLinker* opConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); opConLinker->init(opConcept,negated); concept->addOperandLinker(opConLinker); concept->incOperandCount(); } CConcept* CFullNominalSchemaGroundingPreProcess::createNominalSchemaConceptCopy(CConcept* concept) { CConcept* conceptCopy = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); conceptCopy->initConceptCopy(concept); conceptCopy->setOperandCount(0); conceptCopy->setConceptTag(mTBox->getNextConceptID()); mConceptVec->setData(conceptCopy->getConceptTag(),conceptCopy); ++mStatCreatedConceptCount; return conceptCopy; } CConcept* CFullNominalSchemaGroundingPreProcess::createGroundedNominalSchemaConcept(CConcept* concept, CBOXHASH* templConNomSchConHash, QHash::const_iterator >* nomSchConIndividualItHash) { if (templConNomSchConHash->contains(concept)) { cint64 opCode = concept->getOperatorCode(); if (opCode == CCNOMVAR) { QSet::const_iterator nomVarIt = nomSchConIndividualItHash->value(concept); CConcept* nominalConcept = *nomVarIt; return nominalConcept; } QByteArray conceptNomSchemIndiConceptByteArray; if (mConfReuseGroundedNominalSchemaConcepts) { conceptNomSchemIndiConceptByteArray.append(QByteArray::number((cint64)concept)); FOREACHIT (CConcept* nomSchemConcept, templConNomSchConHash->values(concept)) { QSet::const_iterator nomVarIt = nomSchConIndividualItHash->value(nomSchemConcept); CConcept* indiConcept = *nomVarIt; conceptNomSchemIndiConceptByteArray.append(QByteArray::number((cint64)indiConcept)); } CConcept* replaceCon = mConceptNomSchemIndiReplaceHash.value(conceptNomSchemIndiConceptByteArray,nullptr); if (replaceCon) { return replaceCon; } } CConcept* copiedConcept = createNominalSchemaConceptCopy(concept); for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); bool opConNegation = opConLinkerIt->isNegated(); CConcept* newOpConcept = createGroundedNominalSchemaConcept(opConcept,templConNomSchConHash,nomSchConIndividualItHash); addConceptOperand(copiedConcept,newOpConcept,opConNegation); } if (mConfReuseGroundedNominalSchemaConcepts) { mConceptNomSchemIndiReplaceHash.insert(conceptNomSchemIndiConceptByteArray,copiedConcept); } return copiedConcept; } else { return concept; } } CConcept* CFullNominalSchemaGroundingPreProcess::createNominalSchemaAxiomCollectionConcept(CConcept* concept, bool negated, CNominalSchemaTemplate* nsTemplate) { ++mStatReplacedConceptCount; if (mCollConHash.contains(QPair(concept,negated))) { return mCollConHash.value(QPair(concept,negated)); } ++mStatGroundedTemplateCount; CConcept* collConcept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); collConcept->initConcept(); collConcept->setConceptTag(mTBox->getNextConceptID()); collConcept->setOperatorCode(CCAND); mConceptVec->setData(collConcept->getConceptTag(),collConcept); CBOXHASH* templConNomSchConHash = nsTemplate->getTemplateConceptNominalSchemaConceptHash(); CBOXSET* nomSchConSet = nsTemplate->getNominalSchemaConceptSet(); QHash::const_iterator > nomSchConIndividualItHash; QSet::const_iterator indiIt = mNominalConceptSet.constBegin(); QSet::const_iterator indiItEnd = mNominalConceptSet.constEnd(); FOREACHIT (CConcept* nomSchCon, *nomSchConSet) { nomSchConIndividualItHash.insert(nomSchCon,indiIt); } bool conVarItFinished = false; while (!conVarItFinished) { ++mStatInstantiatedAxiomsCount; CConcept* templateConcept = nsTemplate->getTemplateConcept(); CConcept* groundedConcept = createGroundedNominalSchemaConcept(templateConcept,templConNomSchConHash,&nomSchConIndividualItHash); addConceptOperand(collConcept,groundedConcept,negated); QHash::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin(); QHash::const_iterator >::const_iterator variableItEnd = nomSchConIndividualItHash.constEnd(); QSet::const_iterator varIndiIt = variableIt.value(); CConcept* varConcept = variableIt.key(); ++varIndiIt; bool conVarIteration = true; while (varIndiIt == indiItEnd && conVarIteration) { conVarIteration = false; nomSchConIndividualItHash.insert(varConcept,indiIt); ++variableIt; if (variableIt == variableItEnd) { conVarItFinished = true; } else { varIndiIt = variableIt.value(); varConcept = variableIt.key(); ++varIndiIt; if (varIndiIt == indiItEnd) { conVarIteration = true; } } } nomSchConIndividualItHash.insert(varConcept,varIndiIt); } mCollConHash.insert(QPair(concept,negated),collConcept); return collConcept; } }; // end namespace Preprocess }; // end namespace Reasoner }; // end namespace Konclude