/*
* 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 "COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler.h"
namespace Konclude {
namespace Reasoner {
namespace Answerer {
COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler(COptimizedComplexVariableAbsorptionBasedHandlingQueryPartData* queryPart, COptimizedComplexExpressionOntologyAnsweringItem* ontoAnsweringItem, COccurrenceStatisticsCacheReader* occStatsCacheReader) : COptimizedComplexVariableAbstractAbsorptionBasedQueryPartHandler(queryPart, ontoAnsweringItem) {
mOntology = mOntoAnsweringItem->getOntology();
mOccStatsCacheReader = occStatsCacheReader;
mConfOccurrenceStatisticsCollection = true;
mConfOccurrenceStatisticsBasedAbsorptionOrder = true;
mConfPrioritizePrepareVariables = false;
}
COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::readConfig(CCalculationConfigurationExtension* config) {
COptimizedComplexVariableAbstractAbsorptionBasedQueryPartHandler::readConfig(config);
mConfOccurrenceStatisticsBasedAbsorptionOrder = CConfigDataReader::readConfigInteger(config, "Konclude.Answering.QueryAbsorption.OccurrenceStatisticsBasedAbsorptionOrder", true);
mConfOccurrenceStatisticsCollection = CConfigDataReader::readConfigBoolean(config, "Konclude.Calculation.Optimization.OccurrenceStatisticsCollecting", true);
return this;
}
CVariable* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::getPropagationVariableForVariableExpression(CExpressionVariable* expVar) {
cint64 nextVariableId = mOntoAnsweringItem->getNextVariableId();
QHash* variableExpressionVariableHash = mQueryPart->getVariableExpressionVariableHash();
QHash* expressionVariableVariableHash = mQueryPart->getExpressionVariableVariableHash();
CVariable* variable = variableExpressionVariableHash->value(expVar);
if (!variable) {
variable = new CVariable();
variable->initVariable(nullptr, nextVariableId++);
variableExpressionVariableHash->insert(expVar, variable);
expressionVariableVariableHash->insert(variable, expVar);
#ifndef KONCLUDE_FORCE_ALL_DEBUG_DEACTIVATED
variable->mDebugVariableName = expVar->getName();
#endif
}
return variable;
}
COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::absorbQueryPart() {
QSet* absorptionVariableSet = mQueryPart->getAbsorptionVariableSet();
QSet* anonymousVariableSet = mQueryPart->getAnonymousVariableSet();
CExpressionVariable* currentVariable = mQueryPart->getLastTriggerVariable();
if (!currentVariable) {
QList remainingVarList(getAbsorptionVariableList());
bool hasIndividualVariables = false;
for (CExpressionVariable* variable : remainingVarList) {
if (!anonymousVariableSet->contains(variable)) {
hasIndividualVariables = true;
}
}
mQueryPart->setHasIndividualVariables(hasIndividualVariables);
if (!mOntoAnsweringItem->getTestingOntology()->getABox()->hasUniversalConnectionIndividual()) {
bool topObjProProp = checkHasTopObjectPropertyPropagation();
if (topObjProProp) {
mQueryPart->setTopObjectPropertyUsage(topObjProProp);
}
}
currentVariable = remainingVarList.takeFirst();
}
while (currentVariable) {
handleCurrentVariableSwitch(currentVariable);
QList selfPropAssList = mQueryPart->getSelfPropertyAssertions(currentVariable);
while (!selfPropAssList.isEmpty()) {
CObjectPropertyAssertionExpression* propAss = selfPropAssList.takeFirst();
absorbObjectPropertyAssertion(currentVariable, propAss);
}
QList propagationVarList;
QList propAssList = mQueryPart->getNeighbouringPropertyAssertions(currentVariable);
while (!propAssList.isEmpty()) {
propAssList = getOrderedObjectPropertyAbsorptionList(currentVariable, propAssList);
CObjectPropertyAssertionExpression* propAss = propAssList.takeFirst();
if (propAssList.isEmpty() || !mQueryPart->isPropertyNeighbouringRemovalDisconnecting(currentVariable, propAss)) {
CExpressionVariable* otherVar = absorbStraightObjectPropertyAssertionPath(currentVariable, propAss);
if (otherVar != currentVariable) {
propagationVarList.append(otherVar);
}
propAssList = mQueryPart->getNeighbouringPropertyAssertions(currentVariable);
}
}
QList objectPropertyPath;
CExpressionVariable* nextVariable = findNextAbsorptionVariable(currentVariable, propagationVarList, objectPropertyPath);
propagateAbsorptionOverObjectPropertyAssertionPath(currentVariable, objectPropertyPath);
currentVariable = nextVariable;
}
return this;
}
QList COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::getAbsorptionVariableList() {
QSet* absorbtionVariableSet = mQueryPart->getAbsorptionVariableSet();
return getFilteredOrderedVariableAbsorptionList(absorbtionVariableSet->toList());
}
QList COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::getFilteredOrderedVariableAbsorptionList(QList varExpList) {
QSet* anonymousVariableSet = mQueryPart->getAnonymousVariableSet();
QList absorbableDistVarList;
QList absorbableDistVarMultiList;
QList absorbableNonDistVarList;
QList absorbableNonDistVarMultiList;
QList remainingVarList;
for (CExpressionVariable* var : varExpList) {
QList neighPropAssList = mQueryPart->getNeighbouringPropertyAssertions(var);
QList selfPropAssList = mQueryPart->getSelfPropertyAssertions(var);
bool hasAbsorbableProperty = false;
if (selfPropAssList.isEmpty()) {
for (CObjectPropertyAssertionExpression* propAss : neighPropAssList) {
if (neighPropAssList.size() == 1 || !mQueryPart->isPropertyNeighbouringRemovalDisconnecting(var, propAss)) {
hasAbsorbableProperty = true;
break;
}
}
}
bool prioritizedVariable = !anonymousVariableSet->contains(var);
if (mConfPrioritizePrepareVariables && !prioritizedVariable) {
if (mQueryPart->getPrepareVariableSet()->contains(var)) {
prioritizedVariable = true;
}
}
if (prioritizedVariable) {
if (hasAbsorbableProperty) {
if (neighPropAssList.size() > 2) {
absorbableDistVarMultiList.append(var);
} else {
absorbableDistVarList.append(var);
}
} else {
remainingVarList.append(var);
}
} else {
if (hasAbsorbableProperty) {
if (neighPropAssList.size() > 2 || !selfPropAssList.isEmpty()) {
absorbableNonDistVarMultiList.append(var);
} else {
absorbableNonDistVarList.append(var);
}
} else {
remainingVarList.append(var);
}
}
}
QList absorbVarList;
absorbVarList.append(getOrderedVariableAbsorptionList(absorbableDistVarMultiList));
absorbVarList.append(getOrderedVariableAbsorptionList(absorbableDistVarList));
absorbVarList.append(getOrderedVariableAbsorptionList(absorbableNonDistVarMultiList));
absorbVarList.append(getOrderedVariableAbsorptionList(absorbableNonDistVarList));
absorbVarList.append(getOrderedVariableAbsorptionList(remainingVarList));
return absorbVarList;
}
CExpressionVariable* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::findNextAbsorptionVariable(CExpressionVariable* currentVariable, QList& absorbedPropagatedVariables, QList& objectPropertyPath) {
QList testingVariableList;
QSet testingVariableSet;
QHash variablePredecessorObjectPropertyAssertionHash;
testingVariableSet.insert(currentVariable);
testingVariableList.append(currentVariable);
for (CExpressionVariable* absorbedPropagatedVariable : absorbedPropagatedVariables) {
if (!testingVariableSet.contains(absorbedPropagatedVariable)) {
testingVariableSet.insert(absorbedPropagatedVariable);
testingVariableList.append(absorbedPropagatedVariable);
}
}
testingVariableList = getFilteredOrderedVariableAbsorptionList(testingVariableList);
while (!testingVariableList.isEmpty()) {
CExpressionVariable* nextVariable = testingVariableList.takeFirst();
QList selfPropAssList = mQueryPart->getSelfPropertyAssertions(nextVariable);
bool absorbable = false;
if (!selfPropAssList.isEmpty()) {
absorbable = true;
}
QList propAssList = mQueryPart->getNeighbouringPropertyAssertions(nextVariable);
for (CObjectPropertyAssertionExpression* propAss : propAssList) {
if (propAssList.size() == 1 || !mQueryPart->isPropertyNeighbouringRemovalDisconnecting(nextVariable, propAss)) {
absorbable = true;
break;
} else {
CExpressionVariable* otherVariable = mQueryPart->getOtherVariableExpression(nextVariable, propAss);
if (!testingVariableSet.contains(otherVariable)) {
testingVariableSet.insert(otherVariable);
variablePredecessorObjectPropertyAssertionHash.insert(otherVariable, propAss);
testingVariableList.append(otherVariable);
}
}
}
if (absorbable) {
objectPropertyPath.clear();
CExpressionVariable* predecessorVariable = nextVariable;
while (predecessorVariable) {
CObjectPropertyAssertionExpression* predecessorObjectPropertyAss = variablePredecessorObjectPropertyAssertionHash.value(predecessorVariable);
if (predecessorObjectPropertyAss) {
objectPropertyPath.append(predecessorObjectPropertyAss);
predecessorVariable = mQueryPart->getOtherVariableExpression(nextVariable, predecessorObjectPropertyAss);
}
else {
predecessorVariable = nullptr;
}
}
return nextVariable;
}
}
return nullptr;
}
bool COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::checkVariableCompletelyHandled(CExpressionVariable* currentVariable) {
if (mQueryPart->isVariableHandled(currentVariable)) {
return true;
}
QList selfPropAssList = mQueryPart->getSelfPropertyAssertions(currentVariable);
QList propAssList = mQueryPart->getNeighbouringPropertyAssertions(currentVariable);
bool completelyHandled = propAssList.size() <= 0 && selfPropAssList.isEmpty();
if (completelyHandled) {
mQueryPart->setVariableHandled(currentVariable);
}
return completelyHandled;
}
CExpressionVariable* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::propagateAbsorptionOverObjectPropertyAssertionPath(CExpressionVariable* currentVariable, const QList& objectPropertyPath) {
CExpressionVariable* nextVariable = currentVariable;
for (CObjectPropertyAssertionExpression* objectProperty : objectPropertyPath) {
nextVariable = propagateAbsorptionOverObjectPropertyAssertion(nextVariable, objectProperty);
}
return nextVariable;
}
CExpressionVariable* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::absorbStraightObjectPropertyAssertionPath(CExpressionVariable* currentVariable, CObjectPropertyAssertionExpression* startingProperty) {
CExpressionVariable* nextVariable = absorbObjectPropertyAssertion(currentVariable, startingProperty);
QSet* anonymousVarSet = mQueryPart->getAnonymousVariableSet();
while (nextVariable) {
QList neighbouringPropAssList = mQueryPart->getNeighbouringPropertyAssertions(nextVariable);
QList selfPropAssList = mQueryPart->getSelfPropertyAssertions(nextVariable);
if (neighbouringPropAssList.size() == 1 && selfPropAssList.isEmpty()) {
CObjectPropertyAssertionExpression* nextObjectPropertyAssertion = neighbouringPropAssList.first();
nextVariable = absorbObjectPropertyAssertion(nextVariable, nextObjectPropertyAssertion);
} else {
break;
}
}
return nextVariable;
}
CExpressionVariable* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::absorbObjectPropertyAssertion(CExpressionVariable* currentVariable, CObjectPropertyAssertionExpression* startingProperty) {
CExpressionVariable* variable = propagateAbsorptionOverObjectPropertyAssertion(currentVariable, startingProperty);
mQueryPart->removePropertyAssertion(startingProperty);
return variable;
}
static bool itemSortLessObjectPropertyTermOccurrenceScoreThan(const TObjectPropertyOccurrenceScoreSortingItem& item1, const TObjectPropertyOccurrenceScoreSortingItem& item2) {
return item1.second < item2.second;
}
static bool itemSortLessVariableTermsOccurrenceScoreThan(const TVariableTermsOccurrenceScoreSortingItem& item1, const TVariableTermsOccurrenceScoreSortingItem& item2) {
return item1.second < item2.second;
}
QList COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::getOrderedVariableAbsorptionList(QList varExpList) {
if (!mConfOccurrenceStatisticsBasedAbsorptionOrder || !mConfOccurrenceStatisticsCollection || !mOccStatsCacheReader) {
return varExpList;
}
QList orderedVarExpList;
QList varTermsOccScoreList;
cint64 ontologyId = mOntology->getOntologyID();
for (CExpressionVariable* varExp : varExpList) {
double varOccScore = 0.;
double varClassAssOccScoreMin = 0;
double varClassAssOccScore = 0.;
cint64 varClassAssOccCount = 0;
for (CBuildExpression* classBuildExp : mQueryPart->getVariableClassExpressions(varExp)) {
CClassTermExpression* classExp = dynamic_cast(classBuildExp);
if (dynamic_cast(classExp)) {
CConcept* concept = mOntology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash()->value((CClassTermExpression*)classExp);
if (concept->getOperatorCode() == CCEQ) {
concept = mOntology->getDataBoxes()->getTBox()->getEquivalentConceptCandidateHash(false)->value(concept);
}
COccurrenceStatisticsConceptData conceptOccStatsData = mOccStatsCacheReader->getAccummulatedConceptDataOccurrenceStatistics(ontologyId, concept->getConceptTag());
double conceptOccFactor = conceptOccStatsData.getDeterministicInstanceOccurrencesCount() + conceptOccStatsData.getNonDeterministicInstanceOccurrencesCount() * 2 + conceptOccStatsData.getExistentialInstanceOccurrencesCount() * 1.5 + conceptOccStatsData.getIndividualInstanceOccurrencesCount();
if (varClassAssOccCount != 0) {
varClassAssOccScoreMin = qMin(varClassAssOccScoreMin, conceptOccFactor);
} else {
varClassAssOccScoreMin = conceptOccFactor;
}
varClassAssOccCount++;
}
}
varClassAssOccScore = varClassAssOccScoreMin * (1. / (varClassAssOccCount + 1) + 0.5);
varOccScore += varClassAssOccScore;
QList propAssList = mQueryPart->getNeighbouringPropertyAssertions(varExp);
propAssList.append(mQueryPart->getSelfPropertyAssertions(varExp));
if (!propAssList.isEmpty()) {
double varPropAssOccScore = 0.;
getOrderedObjectPropertyAbsorptionList(varExp, propAssList, &varPropAssOccScore);
varOccScore += varPropAssOccScore / 3.;
}
varTermsOccScoreList.append(TVariableTermsOccurrenceScoreSortingItem(varExp, varOccScore));
}
qSort(varTermsOccScoreList.begin(), varTermsOccScoreList.end(), itemSortLessVariableTermsOccurrenceScoreThan);
for (TVariableTermsOccurrenceScoreSortingItem varScoreItem : varTermsOccScoreList) {
CExpressionVariable* varExp = varScoreItem.first;
orderedVarExpList.append(varExp);
}
return orderedVarExpList;
}
QList COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::getOrderedObjectPropertyAbsorptionList(CExpressionVariable* currentVariable, QList objectPropertyList, double* totalOccScore) {
if (!mConfOccurrenceStatisticsBasedAbsorptionOrder || !mConfOccurrenceStatisticsCollection || !mOccStatsCacheReader) {
return objectPropertyList;
}
QList orderedList;
QList propOccScoreList;
cint64 ontologyId = mOntology->getOntologyID();
//bool hasLikeRole = false;
double totalScore = 0;
for (CObjectPropertyAssertionExpression* propAssExp : objectPropertyList) {
CRole* role = mOntology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value((CObjectPropertyTermExpression*)propAssExp->getObjectPropertyTermExpression());
if (role) {
//if (CIRIName::getRecentIRIName(role->getPropertyNameLinker()) == "http://semantics.crl.ibm.com/univ-bench-dl.owl#like") {
// hasLikeRole = true;
//}
double complexFactor = 1.;
if (role->isComplexRole()) {
complexFactor = 2.5;
}
COccurrenceStatisticsRoleData roleOccStatsData = mOccStatsCacheReader->getAccummulatedRoleDataOccurrenceStatistics(ontologyId, role->getRoleTag());
double roleOccFactor = complexFactor * (roleOccStatsData.getDeterministicInstanceOccurrencesCount() + roleOccStatsData.getNonDeterministicInstanceOccurrencesCount() * 2 + roleOccStatsData.getExistentialInstanceOccurrencesCount() * 1.5 + roleOccStatsData.getIndividualInstanceOccurrencesCount());
totalScore += roleOccFactor;
propOccScoreList.append(TObjectPropertyOccurrenceScoreSortingItem(propAssExp, roleOccFactor));
}
}
qSort(propOccScoreList.begin(), propOccScoreList.end(), itemSortLessObjectPropertyTermOccurrenceScoreThan);
//if (!propOccScoreList.isEmpty() && hasLikeRole) {
// CRole* role = mOntology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash()->value((CObjectPropertyTermExpression*)propOccScoreList.last().first->getObjectPropertyTermExpression());
// if (CIRIName::getRecentIRIName(role->getPropertyNameLinker()) != "http://semantics.crl.ibm.com/univ-bench-dl.owl#like") {
// bool debug = true;
// if (debug) {
// getOrderedObjectPropertyAbsorptionList(currentVariable, objectPropertyList, totalOccScore);
// }
// }
//}
for (TObjectPropertyOccurrenceScoreSortingItem propScoreItem : propOccScoreList) {
CObjectPropertyAssertionExpression* propAssExp = propScoreItem.first;
orderedList.append(propAssExp);
}
if (totalOccScore) {
*totalOccScore = totalScore;
}
return orderedList;
}
CConcept* COptimizedComplexVariableAbstractNonDisconnectingAbsorptionBasedQueryPartHandler::createNewConcept() {
CConcept* concept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
concept->initConcept();
cint64 nextConTag = mTBox->getNextConceptID();
concept->initTag(nextConTag);
mConceptVec->setLocalData(nextConTag, concept);
return concept;
}
}; // end namespace Answerer
}; // end namespace Reasoner
}; // end namespace Konclude