/* * 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 "CNominalSchemaTemplateExtractionPreProcess.h" namespace Konclude { namespace Reasoner { namespace Preprocess { CNominalSchemaTemplateExtractionPreProcess::CNominalSchemaTemplateExtractionPreProcess() { } CNominalSchemaTemplateExtractionPreProcess::~CNominalSchemaTemplateExtractionPreProcess() { } CConcreteOntology *CNominalSchemaTemplateExtractionPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) { bool nominalSchemaConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNominalSchemaUsed(); if (nominalSchemaConstructsUsed) { mStatCreatedTemplateCount = 0; mStatReplacedConceptCount = 0; mNomSchTemplVec = nullptr; mTBox = ontology->getDataBoxes()->getTBox(); CRBox *rBox = ontology->getDataBoxes()->getRBox(); CABox *aBox = ontology->getDataBoxes()->getABox(); mMBox = ontology->getDataBoxes()->getMBox(); 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; mIndividualVector = aBox->getIndividualVector(false); mIndividualCount = 0; if (mIndividualVector) { mIndividualCount = mIndividualVector->getItemCount(); } bool nominalSchemaConcepts = false; for (cint64 i = 0; !nominalSchemaConcepts && i < mConceptCount; ++i) { CConcept* concept = mConceptVec->getData(i); if (concept) { cint64 conOpCode = concept->getOperatorCode(); if (conOpCode == CCNOMVAR) { nominalSchemaConcepts = true; } } } if (nominalSchemaConcepts) { for (cint64 i = 0; i < mConceptCount; ++i) { CConcept* concept = mConceptVec->getLocalData(i); if (concept) { cint64 conOpCode = concept->getOperatorCode(); if (conOpCode == CCEQ) { bool foundNominalSchemaConcept = false; for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt && !foundNominalSchemaConcept; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); bool opConNegation = opConLinkerIt->isNegated(); foundNominalSchemaConcept = hasNominalSchemaConcept(opConcept); } if (foundNominalSchemaConcept) { transformEquivalentConceptToGCI(concept); } } } } 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(); if (hasNominalSchemaConcept(opConcept)) { ++mStatReplacedConceptCount; CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation); CConcept* templRefConcept = nomSchTempl->getReferenceConcept(); opConLinkerIt->setData(templRefConcept); } } } } } 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(); if (hasNominalSchemaConcept(opConcept)) { ++mStatReplacedConceptCount; CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation); CConcept* templRefConcept = nomSchTempl->getReferenceConcept(); domConLinkerIt->setData(templRefConcept); } } for (CSortedNegLinker* rangConLinkerIt = role->getRangeConceptList(); rangConLinkerIt; rangConLinkerIt = rangConLinkerIt->getNext()) { CConcept* opConcept = rangConLinkerIt->getData(); bool opConNegation = rangConLinkerIt->isNegated(); if (hasNominalSchemaConcept(opConcept)) { ++mStatReplacedConceptCount; CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation); CConcept* templRefConcept = nomSchTempl->getReferenceConcept(); rangConLinkerIt->setData(templRefConcept); } } } } for (CSortedNegLinker* gciConLinkerIt = mTopConcept->getOperandList(); gciConLinkerIt; gciConLinkerIt = gciConLinkerIt->getNext()) { CConcept* opConcept = gciConLinkerIt->getData(); bool opConNegation = gciConLinkerIt->isNegated(); if (hasNominalSchemaConcept(opConcept)) { if (!removeSingleAbsorbableNominalSchemaConcepts(opConcept,opConNegation)) { ++mStatReplacedConceptCount; CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation); CConcept* templRefConcept = nomSchTempl->getReferenceConcept(); gciConLinkerIt->setData(templRefConcept); } } } 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(); if (hasNominalSchemaConcept(assCon)) { ++mStatReplacedConceptCount; CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(assCon,assConNegation); CConcept* templRefConcept = nomSchTempl->getReferenceConcept(); assConLinkerIt->setData(templRefConcept); } } } } } } LOG(INFO,"::Konclude::Reasoner::Preprocess::NominalSchemaTemplateExtractor",logTr("Extracted %1 nominal schema templates, replaced %2 concepts.").arg(mStatCreatedTemplateCount).arg(mStatReplacedConceptCount),this); } return ontology; } bool CNominalSchemaTemplateExtractionPreProcess::removeSingleAbsorbableNominalSchemaConcepts(CConcept* concept, bool negation) { bool allRemoved = true; QHash nominalSchemaConceptCountHash; countNominalSchemaConcepts(concept,&nominalSchemaConceptCountHash); QSet absorbableNominalVariableSet; if (findAbsorbableNominalSchemas(concept,negation,&absorbableNominalVariableSet)) { QSet removeNominalVariableSet; for (QHash::const_iterator it = nominalSchemaConceptCountHash.constBegin(), itEnd = nominalSchemaConceptCountHash.constEnd(); it != itEnd; ++it) { cint64 nomSchCount = it.value(); CConcept* concept = it.key(); if (nomSchCount <= 1 && absorbableNominalVariableSet.contains(concept)) { removeNominalVariableSet.insert(concept); } else { allRemoved = false; } } if (!removeNominalVariableSet.isEmpty()) { CConcept* replaceConcept = mTBox->getIndividualTriggerConcept(); replaceNominalSchemasConcepts(concept,replaceConcept,removeNominalVariableSet); } } else { allRemoved = false; } return allRemoved; } void CNominalSchemaTemplateExtractionPreProcess::replaceNominalSchemasConcepts(CConcept* concept, CConcept* replacingConcept, const QSet& removeNominalVariableSet) { cint64 conOpCode = concept->getOperatorCode(); if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) { } else { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); if (removeNominalVariableSet.contains(opConcept)) { opConLinkerIt->setData(replacingConcept); } else { replaceNominalSchemasConcepts(opConcept,replacingConcept,removeNominalVariableSet); } } } } void CNominalSchemaTemplateExtractionPreProcess::countNominalSchemaConcepts(CConcept* concept, QHash* nominalSchemaConceptCountHash) { cint64 conOpCode = concept->getOperatorCode(); if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) { } else if (conOpCode == CCNOMVAR) { cint64 prevCount = nominalSchemaConceptCountHash->value(concept,0); nominalSchemaConceptCountHash->insert(concept,prevCount+1); } else { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); countNominalSchemaConcepts(opConcept,nominalSchemaConceptCountHash); } } } bool CNominalSchemaTemplateExtractionPreProcess::findAbsorbableNominalSchemas(CConcept* concept, bool negation, QSet* absorbableNominalVariableSet) { cint64 opCode = concept->getOperatorCode(); cint64 param = concept->getParameter(); if (negation && (opCode == CCSOME) || !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 || opCode == CCAND) || !negation && (opCode == CCAND || opCode == CCOR)) { bool oneAbsorbable = true; 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 == CCNOMVAR)) { absorbableNominalVariableSet->insert(concept); return true; } return false; } void CNominalSchemaTemplateExtractionPreProcess::addConceptOperand(CConcept* concept, CConcept* opConcept, bool negated) { CSortedNegLinker* opConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); opConLinker->init(opConcept,negated); concept->addOperandLinker(opConLinker); concept->incOperandCount(); } CConcept* CNominalSchemaTemplateExtractionPreProcess::transformEquivalentConceptToGCI(CConcept* eqConcept) { eqConcept->setOperatorCode(CCSUB); CConcept* concept = createNewConcept(); concept->setOperatorCode(CCOR); mConceptVec->setData(concept->getConceptTag(),concept); addConceptOperand(eqConcept,concept,false); for (CSortedNegLinker* opConLinkerIt = eqConcept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); bool opConNegation = opConLinkerIt->isNegated(); addConceptOperand(eqConcept,opConcept,!opConNegation); } mTopConcept = CConceptRoleIndividualLocator::getLocatedConcept(mTopConcept,mOnto); addConceptOperand(mTopConcept,concept,false); return concept; } CConcept* CNominalSchemaTemplateExtractionPreProcess::createNewConcept() { CConcept* concept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); concept->initConcept(); cint64 nextConTag = mTBox->getNextConceptID(); concept->initTag(nextConTag); return concept; } CConcept* CNominalSchemaTemplateExtractionPreProcess::createNominalSchemaTemplateReferenceConcept(CNominalSchemaTemplate* nsTemplate) { CConcept* concept = createNewConcept(); concept->setOperatorCode(CCNOMTEMPLREF); concept->setParameter(nsTemplate->getNominalSchemaTemplateTag()); mConceptVec->setData(concept->getConceptTag(),concept); nsTemplate->setReferenceConcept(concept); return concept; } CNominalSchemaTemplate* CNominalSchemaTemplateExtractionPreProcess::getNominalSchemaTemplate(CConcept* concept, bool negation) { CNominalSchemaTemplate* nsTemplate = mConceptNominalSchemaTemplateHash.value(concept); if (!nsTemplate) { ++mStatCreatedTemplateCount; nsTemplate = CObjectAllocator< CNominalSchemaTemplate >::allocateAndConstruct(mMemMan); CBOXSET* nominalSchemaConceptSet = CObjectAllocator< CBOXSET >::allocateAndConstruct(mMemMan); CBOXHASH* conceptNominalSchemaConceptHash = CObjectAllocator< CBOXHASH >::allocateAndConstruct(mMemMan); CBOXHASH* absorbableConceptNominalSchemaConceptHash = CObjectAllocator< CBOXHASH >::allocateAndConstruct(mMemMan); nsTemplate->initNominalSchemaTemplate(nominalSchemaConceptSet,conceptNominalSchemaConceptHash,absorbableConceptNominalSchemaConceptHash); if (!mNomSchTemplVec) { mNomSchTemplVec = mMBox->getNominalSchemaTemplateVector(); } cint64 nextNomSchTemplID = mNomSchTemplVec->getItemCount(); nsTemplate->setNominalSchemaTemplateTag(nextNomSchTemplID); mNomSchTemplVec->setData(nextNomSchTemplID,nsTemplate); nsTemplate->setTemplateConcept(concept); collectNominalSchemaConcepts(concept,nominalSchemaConceptSet); createNominalSchemaTemplateReferenceConcept(nsTemplate); FOREACHIT (CConcept* nomSchConcept, *nominalSchemaConceptSet) { QSet testedNomSchemConSet; hasNominalSchemaConceptFillHash(concept,conceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemConSet); QSet testedNomSchemAbsorbedConSet; hasNominalSchemaAbsorbableConceptFillHash(concept,negation,absorbableConceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemAbsorbedConSet); } mConceptNominalSchemaTemplateHash.insert(concept,nsTemplate); } return nsTemplate; } bool CNominalSchemaTemplateExtractionPreProcess::hasNominalSchemaAbsorbableConceptFillHash(CConcept* concept, bool negation, CBOXHASH* absorbableConceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet* testedConceptSet) { cint64 conOpCode = concept->getOperatorCode(); if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) { return false; } bool foundAbsorbableNominalSchemaConcept = false; if (negation && concept == nominalSchemaConcept) { foundAbsorbableNominalSchemaConcept = true; } else { cint64 conCode = concept->getOperatorCode(); if (negation && (conCode == CCSOME) || !negation && (conCode == CCALL)) { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); foundAbsorbableNominalSchemaConcept |= hasNominalSchemaAbsorbableConceptFillHash(opConcept,negation^opConLinkerIt->isNegated(),absorbableConceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet); } } else if (!negation && (conCode == CCAND || conCode == CCOR) || negation && (conCode == CCOR || conCode == CCAND)) { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); foundAbsorbableNominalSchemaConcept |= hasNominalSchemaAbsorbableConceptFillHash(opConcept,negation^opConLinkerIt->isNegated(),absorbableConceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet); } } } if (foundAbsorbableNominalSchemaConcept) { if (!testedConceptSet->contains(concept)) { testedConceptSet->insert(concept); absorbableConceptNominalSchemaConceptHash->insertMulti(concept,nominalSchemaConcept); } } return foundAbsorbableNominalSchemaConcept; } bool CNominalSchemaTemplateExtractionPreProcess::hasNominalSchemaConceptFillHash(CConcept* concept, CBOXHASH* conceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet* testedConceptSet) { cint64 conOpCode = concept->getOperatorCode(); if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) { return false; } bool foundNominalSchemaConcept = false; if (concept == nominalSchemaConcept) { foundNominalSchemaConcept = true; } else { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); foundNominalSchemaConcept |= hasNominalSchemaConceptFillHash(opConcept,conceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet); } } if (foundNominalSchemaConcept) { if (!testedConceptSet->contains(concept)) { testedConceptSet->insert(concept); conceptNominalSchemaConceptHash->insertMulti(concept,nominalSchemaConcept); } } return foundNominalSchemaConcept; } void CNominalSchemaTemplateExtractionPreProcess::collectNominalSchemaConcepts(CConcept* concept, CBOXSET* nominalSchemaConceptSet) { cint64 conOpCode = concept->getOperatorCode(); if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) { } else if (conOpCode == CCNOMVAR) { nominalSchemaConceptSet->insert(concept); } else { for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); collectNominalSchemaConcepts(opConcept,nominalSchemaConceptSet); } } } bool CNominalSchemaTemplateExtractionPreProcess::hasNominalSchemaConcept(CConcept* concept) { cint64 conOpCode = concept->getOperatorCode(); if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) { return false; } else if (conOpCode == CCNOMVAR) { return true; } if (mConceptNominalSchemaHash.contains(concept)) { return mConceptNominalSchemaHash.value(concept); } bool foundNominalSchemaConcept = false; for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt && !foundNominalSchemaConcept; opConLinkerIt = opConLinkerIt->getNext()) { CConcept* opConcept = opConLinkerIt->getData(); foundNominalSchemaConcept = hasNominalSchemaConcept(opConcept); } mConceptNominalSchemaHash.insert(concept,foundNominalSchemaConcept); return foundNominalSchemaConcept; } }; // end namespace Preprocess }; // end namespace Reasoner }; // end namespace Konclude