* gciConLinkerIt = gciConLinker;
while (gciConLinkerIt) {
CConcept* opCon = gciConLinkerIt->getData();
bool opNegation = gciConLinkerIt->isNegated();
bool removed = false;
cint64 opCode = opCon->getOperatorCode();
if (!opNegation && opCode == CCAND || opNegation && opCode == CCOR) {
collectConjunctions(opCon,opNegation,replaceConceptList);
removed = true;
}
if (removed) {
if (lastgciConLinker) {
lastgciConLinker->setNext(gciConLinkerIt->getNext());
} else {
topConcept->setOperandList(gciConLinkerIt->getNext());
}
topConcept->incOperandCount(-1);
} else {
lastgciConLinker = gciConLinkerIt;
}
gciConLinkerIt = gciConLinkerIt->getNext();
}
for (QList< TConceptNegationPair >::const_iterator it = replaceConceptList.constBegin(), itEnd = replaceConceptList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
addConceptToImplied(topConcept,conNegPair.first,conNegPair.second);
}
lastgciConLinker = nullptr;
gciConLinker = topConcept->getOperandList();
gciConLinkerIt = gciConLinker;
while (gciConLinkerIt) {
CConcept* opCon = gciConLinkerIt->getData();
bool opNegation = gciConLinkerIt->isNegated();
++mStatGCITotal;
bool absorbed = false;
mFirstNewConceptTag = mLastNewConceptTag;
//QString iriClassNameString = CIRIName::getRecentIRIName(opCon->getOperandList()->getData()->getClassNameLinker());
//if (iriClassNameString == "http://purl.org/imbi/dco/dco#BacterialInfectiousPathologicalProcess") {
// COntologyTextFormater::writeOntologyToFile(ontology,"xyztTBox.txt");
// bool bug = true;
//}
KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastGCIString = generateDebugGCIConceptString(opCon,opNegation));
if (!absorbed && absorbNominalConceptsToAssertions(opCon, opNegation)) {
++mStatGCIAssertionAbsorbed;
absorbed = true;
}
if (!absorbed && mConfGlobalNegatedSelfRestrictionsToRoleDomainAbsorption && absorbNegatedSelfToRoleDomain(opCon, opNegation)) {
// better for saturation
++mStatGCIAssertionAbsorbed;
absorbed = true;
}
if (!absorbed && absorbNominalSchemaGCIConceptsToTriggeredImplications(opCon,opNegation)) {
++mStatGCINormalSchemaAbsorbed;
absorbed = true;
}
if (!absorbed && absorbGCIConceptsToTriggeredImplications(opCon,opNegation)) {
++mStatGCINormalAbsorbed;
KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCITechniqueString = QString("implication absorbed"));
absorbed = true;
}
if (!absorbed && mConfPartialGCIAbsorption) {
if (absorbPartialGCIConceptsToTriggeredImplications(opCon,opNegation)) {
++mStatGCIPartialAbsorbed;
KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCITechniqueString = QString("partial implication absorbed"));
absorbed = true;
}
}
if (absorbed) {
++mStatGCIAbsorbed;
mLastNewConceptTag = mConceptVec->getItemCount();
KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCIConceptString = generateDebugGeneratedAbsorbedImplicationString(mFirstNewConceptTag,mLastNewConceptTag));
KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCIString = QString("GCI:
\r\n
\r\n%1
\r\n%2 to
\r\n
\r\n%3\r\n\r\n").arg(mDebugLastGCIString).arg(mDebugLastAbsorbedGCITechniqueString).arg(mDebugLastAbsorbedGCIConceptString));
KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugTotalAbsorbedGCIString += mDebugLastAbsorbedGCIString);
if (lastgciConLinker) {
lastgciConLinker->setNext(gciConLinkerIt->getNext());
} else {
topConcept->setOperandList(gciConLinkerIt->getNext());
}
topConcept->incOperandCount(-1);
} else {
lastgciConLinker = gciConLinkerIt;
}
gciConLinkerIt = gciConLinkerIt->getNext();
}
}
if (mConfOnlyPositiveDisjunctionsAbsorption) {
for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
CConcept* concept = mConceptVec->getData(conIdx);
if (concept && concept->hasClassName()) {
collectPositiveConcepts(concept,false,&mPositiveConceptReferencedSet);
}
}
}
if (mConfCardinalityQualificationTriggerAbsorption) {
for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
CConcept* concept = mConceptVec->getLocalData(conIdx);
if (concept) {
cint64 opCode = concept->getOperatorCode();
bool absorbable = false;
bool absorbNeg = false;
bool absorbPos = false;
bool partialAbsorbable = false;
if (opCode == CCATMOST) {
absorbNeg = true;
absorbPos = true;
} else if (opCode == CCATLEAST) {
absorbNeg = false;
absorbPos = true;
}
if (absorbPos) {
if (!mConfOnlyPositiveCardinalityQualificationTriggerAbsorption || mPositiveConceptReferencedSet.contains(TConceptNegationPair(concept,absorbNeg))) {
if (isCardinalityConceptQualificationTriggerAbsorbable(concept,absorbNeg)) {
absorbable = true;
} else if (mConfPartialCardinalityQualificationTriggerAbsorption && isCardinalityConceptPartialQualificationTriggerAbsorbable(concept,absorbNeg)) {
absorbable = true;
}
}
}
CConcept* absorbedImpCon = nullptr;
if (absorbable) {
CConceptRoleBranchingTrigger* branchingTriggers = createCardinalityQualificationPartialAbsorbedTriggers(concept,absorbNeg);
mBranchTriggVec->setData(conIdx,branchingTriggers);
}
}
}
}
createConceptOfInterestAbsorptions(false);
createDisjunctionAbsorptions(false);
for (QList*>::const_iterator it = mLaterTopConceptTriggerAddList.constBegin(), itEnd = mLaterTopConceptTriggerAddList.constEnd(); it != itEnd; ++it) {
CSortedNegLinker* newOpLinker = *it;
topConcept->addOperandLinker(newOpLinker);
topConcept->incOperandCount();
}
asorbForallsToRanges(topConcept);
mStatInvRolesGenerated = mRoleInverseRoleCreateHash.count();
CConcreteOntologyInverseRoleBuilder::createDelayedInverseRoles(&mRoleInverseRoleCreateHash,mOnto);
optimizeTriggerStructure();
LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 of %2 equivalence class definitions.").arg(mStatEqAbsorbed).arg(mStatEqTotal),this);
LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 of %2 GCI definitions.").arg(mStatGCIAbsorbed).arg(mStatGCITotal),this);
if (mStatGCITotal > 0) {
LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 GCI definitions only partially and extended %2 absorptions partially.").arg(mStatGCIPartialAbsorbed).arg(mStatGCIAbsorptionPartialExtended),this);
}
if (mStatGCINormalSchemaAbsorbed > 0) {
LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 GCI with nominal schemas.").arg(mStatGCINormalSchemaAbsorbed),this);
}
if (mStatGCIAssertionAbsorbed > 0) {
LOG(INFO, "::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber", logTr("Absorbed %1 GCI to assertions.").arg(mStatGCIAssertionAbsorbed), this);
}
LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Generated %1 triggered implication concepts and %2 additional inverse roles.").arg(mStatImplConceptsGenerated).arg(mStatInvRolesGenerated),this);
return ontology;
}
CConcreteOntology* CTriggeredImplicationBinaryAbsorberPreProcess::continuePreprocessing() {
if (mOnto) {
createConceptOfInterestAbsorptions(true);
createDisjunctionAbsorptions(true);
}
return mOnto;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createConceptOfInterestAbsorptions(bool continuationExtension) {
CBOXLIST* conIntList = mTBox->getConceptOfInterestList(false);
if (conIntList && !conIntList->isEmpty()) {
CBOXSET* triggeredConIntSet = mTBox->getTriggeredConceptOfInterestSet(true);
cint64 conIntCount = conIntList->count();
for (cint64 triggeredCount = triggeredConIntSet->count(); triggeredCount < conIntCount; ++triggeredCount) {
TConceptNegPair conNegPair(conIntList->at(triggeredCount));
CConcept* concept = conNegPair.first;
bool negation = conNegPair.second;
if (!triggeredConIntSet->contains(conNegPair)) {
createConceptOfInterestAbsorption(concept, negation, continuationExtension);
triggeredConIntSet->insert(conNegPair);
collectPositiveConcepts(concept, negation, &mPositiveConceptReferencedSet);
}
}
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorptions(bool continuationExtension) {
cint64 conceptCount = mConceptVec->getItemCount();
if (mConfAbsorbDisjunctions || mConfPartialDisjunctionsAbsorption || mConfAbsorbSimpleDisjunctions) {
for (cint64 conIdx = mLastDisjunctId; conIdx < conceptCount; conIdx++) {
CConcept* concept = mConceptVec->getLocalData(conIdx);
if (concept) {
bool requiresBackpropagation = false;
if (continuationExtension && mLastDisjunctId > 0) {
requiresBackpropagation = true;
}
cint64 opCode = concept->getOperatorCode();
bool absorb = false;
bool absorbable = false;
bool absorbNeg = false;
bool absorbPos = false;
bool partialAbsorbable = false;
cint64 opCount = concept->getOperandCount();
if (opCount > 1) {
if (opCode == CCAND) {
absorbNeg = true;
absorbPos = true;
absorb = true;
} else if (opCode == CCOR) {
absorbNeg = false;
absorbPos = true;
absorb = true;
}
if (absorb) {
bool localRepData = false;
CReplacementData* prevReplData = mImpRepVec->getData(conIdx, &localRepData);
if ((!prevReplData || !localRepData)) {
if (absorbPos) {
if (!mConfOnlyPositiveDisjunctionsAbsorption || mPositiveConceptReferencedSet.contains(TConceptNegationPair(concept, absorbNeg))) {
if (mConfAbsorbSimpleDisjunctions && isDisjunctionConceptSimpleTriggeredImplicationAbsorbable(concept, absorbNeg)) {
absorbable = true;
} else if (mConfAbsorbDisjunctions && isDisjunctionConceptTriggeredImplicationAbsorbable(concept, absorbNeg)) {
// add implication trigger absorption
absorbable = true;
} else if (mConfPartialDisjunctionsAbsorption && isDisjunctionConceptPartialTriggeredImplicationAbsorbable(concept, absorbNeg)) {
partialAbsorbable = true;
}
}
}
CConcept* absorbedImpCon = nullptr;
if (!requiresBackpropagation) {
if (absorbable) {
absorbedImpCon = createDisjunctionAbsorbedTriggeredImplication(concept, absorbNeg);
} else if (partialAbsorbable) {
CConceptRoleBranchingTrigger* branchingTriggers = createDisjunctionPartialAbsorbedBranchTriggers(concept, absorbNeg);
mBranchTriggVec->setData(concept->getConceptTag(), branchingTriggers);
}
} else {
if (absorbable || partialAbsorbable) {
if (!mCreatedImpliedDisjunctions.contains(concept)) {
CConcept* disjBackPropTrigger = createTriggerConcept(true);
absorbedImpCon = createDisjunctionAbsorbedBackpropagationTriggeredImplication(concept, absorbNeg, disjBackPropTrigger);
addUnfoldingConceptForConcept(disjBackPropTrigger, absorbedImpCon, false);
absorbedImpCon = disjBackPropTrigger;
}
}
}
if (absorbedImpCon) {
CReplacementData* replData = prevReplData;
if (!localRepData) {
replData = CObjectAllocator::allocateAndConstruct(mMemMan);
replData->initReplacementData(prevReplData);
mImpRepVec->setData(concept->getConceptTag(), replData);
}
replData->setImplicationReplacementConcept(absorbedImpCon);
}
}
}
}
}
}
mLastDisjunctId = conceptCount;
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::asorbForallsToRanges(CConcept* topConcept) {
CSortedNegLinker* gciConLinker = topConcept->getOperandList();
CSortedNegLinker* lastgciConLinker = nullptr;
CSortedNegLinker* gciConLinkerIt = gciConLinker;
while (gciConLinkerIt) {
CConcept* opCon = gciConLinkerIt->getData();
bool opNegation = gciConLinkerIt->isNegated();
bool removed = false;
cint64 opCode = opCon->getOperatorCode();
if (!opNegation && (opCode == CCALL || opCode == CCIMPLALL) || opNegation && (opCode == CCSOME)) {
CRole* role = opCon->getRole();
CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role,mOnto);
for (CSortedNegLinker* opLinkerIt = opCon->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
addRoleRangeConcept(locatedRole,opLinkerIt->getData(),opLinkerIt->isNegated()^opNegation);
}
removed = true;
}
if (removed) {
if (lastgciConLinker) {
lastgciConLinker->setNext(gciConLinkerIt->getNext());
} else {
topConcept->setOperandList(gciConLinkerIt->getNext());
}
topConcept->incOperandCount(-1);
} else {
lastgciConLinker = gciConLinkerIt;
}
gciConLinkerIt = gciConLinkerIt->getNext();
}
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::collectConjunctions(CConcept* concept, bool negated, QList< TConceptNegationPair >& conjList) {
cint64 opCode = concept->getOperatorCode();
if (!negated && opCode == CCAND || negated && opCode == CCOR) {
for (CSortedNegLinker* opLinkIt = concept->getOperandList(); opLinkIt; opLinkIt = opLinkIt->getNext()) {
CConcept* opConcept = opLinkIt->getData();
bool opNegation = opLinkIt->isNegated()^negated;
collectConjunctions(opConcept,opNegation,conjList);
}
} else {
conjList.append(TConceptNegationPair(concept,negated));
}
return true;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::replaceTrigger(CConcept* baseConcept, CConcept* replaceConcept, bool negated) {
for (CSortedNegLinker* opLinker = replaceConcept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
CConcept* opConcept = opLinker->getData();
bool replaceOperand = true;
bool negatedReplacement = opLinker->isNegated() ^ negated;
if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
if (mTriggCountHash[opConcept].mCount <= 1) {
replaceOperand = false;
replaceTrigger(baseConcept,opConcept,negatedReplacement);
}
}
if (replaceOperand) {
++mStatOptimizedRemovedTriggers;
addUnfoldingConceptForConcept(baseConcept,opConcept,negatedReplacement);
}
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::replaceOneTrigger(CConcept* baseConcept, CConcept* replaceConcept, bool negated) {
for (CSortedNegLinker* opLinker = replaceConcept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
CConcept* opConcept = opLinker->getData();
bool replaceOperand = true;
bool negatedReplacement = opLinker->isNegated() ^ negated;
if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
if (mTriggCountHash[opConcept].mCount <= 1) {
CSortedNegLinker* opOpLinker = opConcept->getOperandList();
if (opOpLinker && !opOpLinker->getNext() && !opOpLinker->getData()->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN)/* != CCIMPL*/) {
replaceOperand = false;
replaceTrigger(baseConcept,opConcept,negatedReplacement);
}
}
}
if (replaceOperand) {
++mStatOptimizedRemovedTriggers;
addUnfoldingConceptForConcept(baseConcept,opConcept,negatedReplacement);
}
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::optimizeTriggerStructure() {
cint64 optimisingRemovedTrigger = 0;
cint64 conceptCount = mConceptVec->getItemCount();
for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
CConcept* concept = mConceptVec->getData(conIdx);
if (concept) {
for (CSortedNegLinker* opLinker = concept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
CConcept* opConcept = opLinker->getData();
if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
mTriggCountHash[opConcept].incCount(1);
}
}
}
}
cint64 brCount = mBranchTriggVec->getItemCount();
for (cint64 brIdx = 0; brIdx < brCount; ++brIdx) {
CConceptRoleBranchingTrigger* brTrigger = mBranchTriggVec->getData(brIdx);
if (brTrigger) {
if (brTrigger->isConceptTrigger()) {
CConcept* concept = brTrigger->getTriggerConcept();
if (concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
mTriggCountHash[concept].incCount(2);
}
}
}
}
for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
CConcept* concept = mConceptVec->getLocalData(conIdx);
if (concept) {
cint64 opCode = concept->getOperatorCode();
if (opCode == CCSUB || opCode == CCAND || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/*opCode == CCIMPLTRIG*/) {
CSortedNegLinker* lastLinker = nullptr;
for (CSortedNegLinker* opLinker = concept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
CConcept* opConcept = opLinker->getData();
bool opNegated = opLinker->isNegated();
if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
if (mTriggCountHash[opConcept].mCount <= 1) {
++optimisingRemovedTrigger;
concept->incOperandCount(-1);
if (lastLinker) {
lastLinker->setNext(opLinker->getNext());
replaceTrigger(concept,opConcept,opNegated);
} else {
replaceTrigger(concept,opConcept,opNegated);
CSortedNegLinker* opLinkerIt = concept->getOperandList();
while (opLinkerIt && opLinkerIt->getNext() != opLinker) {
opLinkerIt = opLinkerIt->getNext();
}
opLinkerIt->setNext(opLinker->getNext());
lastLinker = opLinkerIt;
}
} else {
lastLinker = opLinker;
}
}
}
} else if (concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN | CConceptOperator::CCF_VARBINDGROUND)/*opCode == CCIMPL*/) {
CSortedNegLinker* opLinker = concept->getOperandList();
if (opLinker) {
CConcept* opConcept = opLinker->getData();
bool opNegated = opLinker->isNegated();
if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
if (mTriggCountHash[opConcept].mCount <= 1) {
CSortedNegLinker* opOpLinker = opConcept->getOperandList();
if (opOpLinker && !opOpLinker->getNext() && !opOpLinker->getData()->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN)/* != CCIMPL*/) {
++optimisingRemovedTrigger;
concept->setOperandList(opLinker->getNext());
concept->incOperandCount(-1);
replaceOneTrigger(concept,opConcept,opNegated);
}
}
}
}
} else {
if (concept->getOperandCount() == 1) {
CSortedNegLinker* opLinker = concept->getOperandList();
CConcept* opConcept = opLinker->getData();
bool opNegated = opLinker->isNegated();
if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
if (mTriggCountHash[opConcept].mCount <= 1) {
CSortedNegLinker* opOpLinker = opConcept->getOperandList();
if (opOpLinker && !opOpLinker->getNext() && !opOpLinker->getData()->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN)/* != CCIMPL*/) {
++optimisingRemovedTrigger;
concept->setOperandList(nullptr);
concept->incOperandCount(-1);
replaceOneTrigger(concept,opConcept,opNegated);
}
}
}
}
}
}
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::collectPositiveConcepts(CConcept* initalConcept, bool initalNegated, QSet* positiveConceptSet, bool recursiveDefinition) {
TConceptNegationPair processConNegPair(initalConcept,initalNegated);
if (!positiveConceptSet->contains(processConNegPair)) {
positiveConceptSet->insert(processConNegPair);
QList processConceptList;
processConceptList.append(processConNegPair);
while (!processConceptList.isEmpty()) {
TConceptNegationPair conNegPair(processConceptList.takeFirst());
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
cint64 opCode = concept->getOperatorCode();
CConceptOperator* conOperator = concept->getConceptOperator();
CSortedNegLinker* opConLinker = concept->getOperandList();
if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_AND_AQAND_TYPE) || conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_AQALL_TYPE) || (recursiveDefinition && opCode == CCEQ || !negated && opCode == CCSUB) || opCode == CCAQSOME || opCode == CCSOME) {
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegation = opConLinkerIt->isNegated()^negated;
TConceptNegationPair opConNegPair(opConcept,opNegation);
if (!positiveConceptSet->contains(opConNegPair)) {
positiveConceptSet->insert(opConNegPair);
processConceptList.append(opConNegPair);
}
opConLinkerIt = opConLinkerIt->getNext();
}
} else if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE)) {
CSortedNegLinker* firstOpConLinker = opConLinker;
if (firstOpConLinker) {
CConcept* opConcept = firstOpConLinker->getData();
TConceptNegationPair opConNegPair(opConcept,false);
if (!positiveConceptSet->contains(opConNegPair)) {
positiveConceptSet->insert(opConNegPair);
processConceptList.append(opConNegPair);
}
}
} else if (opCode == CCAQCHOOCE) {
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt) {
CConcept* opConcept = opConLinkerIt->getData();
if (opConLinkerIt->isNegated() == negated) {
TConceptNegationPair opConNegPair(opConcept,false);
if (!positiveConceptSet->contains(opConNegPair)) {
positiveConceptSet->insert(opConNegPair);
processConceptList.append(opConNegPair);
}
}
opConLinkerIt = opConLinkerIt->getNext();
}
} else if (opCode == CCATMOST || opCode == CCATLEAST) {
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt) {
CConcept* opConcept = opConLinkerIt->getData();
TConceptNegationPair opConNegPair(opConcept,opConLinkerIt->isNegated());
if (!positiveConceptSet->contains(opConNegPair)) {
positiveConceptSet->insert(opConNegPair);
processConceptList.append(opConNegPair);
}
opConLinkerIt = opConLinkerIt->getNext();
}
} else if (!negated && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE))) {
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt) {
CConcept* opConcept = opConLinkerIt->getData();
TConceptNegationPair opConNegPair(opConcept,opConLinkerIt->isNegated());
if (!positiveConceptSet->contains(opConNegPair)) {
positiveConceptSet->insert(opConNegPair);
processConceptList.append(opConNegPair);
}
opConLinkerIt = opConLinkerIt->getNext();
}
}
}
}
}
QString CTriggeredImplicationBinaryAbsorberPreProcess::generateDebugGCIConceptString(CConcept* concept, bool conceptNegation) {
mDebugGCIString = CConceptTextFormater::getConceptString(concept,conceptNegation);
return mDebugGCIString;
}
QString CTriggeredImplicationBinaryAbsorberPreProcess::generateDebugGeneratedAbsorbedImplicationString(cint64 minNewConceptTag, cint64 lastNewConceptTag) {
QString absorbedString;
for (cint64 tag = minNewConceptTag; tag <= lastNewConceptTag; ++tag) {
CConcept* concept = mConceptVec->getData(tag);
if (concept) {
QString tmpString = CConceptTextFormater::getConceptString(concept,false);
absorbedString += QString("%1
\r\n").arg(tmpString);
}
}
mDebugAbsorbedString = absorbedString;
return absorbedString;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createImpliedConcept() {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCAND);
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createCandidateEquivalentConcept(CConcept* eqConcept) {
CConcept* concept = createNewConcept();
addUnfoldingConceptForConcept(concept,eqConcept,false);
concept->setOperatorCode(CCEQCAND);
return concept;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::addConceptToImplied(CConcept* impliedConcept, CConcept* concept, bool negated) {
CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon->init(concept,negated,impliedConcept->getOperandList());
impliedConcept->setOperandList(newBaseOpCon);
impliedConcept->incOperandCount();
return true;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::addSubClassConcept(CConcept* subclassConcept, CConcept* addedConcept, bool negated) {
CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon->init(addedConcept,negated,subclassConcept->getOperandList());
subclassConcept->setOperandList(newBaseOpCon);
subclassConcept->incOperandCount();
subclassConcept->setOperatorCode(CCSUB);
return true;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::addRoleDomainConcept(CRole* role, CConcept* addedConcept, bool negated) {
CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon->init(addedConcept,negated,role->getDomainConceptList());
role->setDomainConceptList(newBaseOpCon);
return true;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::addRoleRangeConcept(CRole* role, CConcept* addedConcept, bool negated) {
CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon->init(addedConcept,negated,role->getRangeConceptList());
role->setRangeConceptList(newBaseOpCon);
return true;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createNewConcept() {
CConcept* concept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
concept->initConcept();
cint64 nextConTag = mTBox->getNextConceptID();
concept->initTag(nextConTag);
mConceptVec->setLocalData(nextConTag, concept);
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createImplicationConcept(CConcept* impliedConcept, bool negated) {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCIMPL);
CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon->init(impliedConcept,negated);
concept->setOperandList(newBaseOpCon);
concept->incOperandCount();
++mStatImplConceptsGenerated;
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createImplicationTriggerConcept(CConcept* impConcept, bool negated) {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCIMPLTRIG);
if (impConcept) {
addConceptToImplied(concept,impConcept,negated);
}
return concept;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::addImplicationTrigger(CConcept* implConcept, CConcept* triggerConcept, bool negated) {
CSortedNegLinker* newTriggerOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newTriggerOpCon->init(triggerConcept,negated,implConcept->getOperandList()->getNext());
implConcept->getOperandList()->setNext(newTriggerOpCon);
implConcept->incOperandCount();
mTriggerImplHash->insertMulti(triggerConcept,implConcept);
return true;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createTriggerPropagationConcept(CConcept* destConcept, CRole* backwardPropRole, bool branchTiggerCreation, bool invsereRolePropagation) {
CConcept* concept = createNewConcept();
CRole* propRole = backwardPropRole;
if (invsereRolePropagation) {
propRole = getInverseRole(backwardPropRole);
}
if (branchTiggerCreation) {
concept->setOperatorCode(CCBRANCHALL);
} else {
concept->setOperatorCode(CCIMPLALL);
}
concept->setRole(propRole);
CSortedNegLinker* newTriggerOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newTriggerOpCon->init(destConcept,false);
concept->setOperandList(newTriggerOpCon);
concept->incOperandCount();
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createNominalImplication(CConcept* destConcept, CIndividual* nominalIndi) {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCNOMINALIMPLI);
concept->setNominalIndividual(nominalIndi);
CSortedNegLinker* newTriggerOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newTriggerOpCon->init(destConcept, false);
concept->setOperandList(newTriggerOpCon);
concept->incOperandCount();
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDatatypeImplication(CConcept* destConcept, CDatatype* datatype) {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCDATATYPEIMPLI);
concept->setDatatype(datatype);
CSortedNegLinker* newTriggerOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newTriggerOpCon->init(destConcept, false);
concept->setOperandList(newTriggerOpCon);
concept->incOperandCount();
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDataLiteralImplication(CConcept* destConcept, CDataLiteral* dataLiteral) {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCDATALITERALIMPLI);
concept->setDataLiteral(dataLiteral);
CSortedNegLinker* newTriggerOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newTriggerOpCon->init(destConcept, false);
concept->setOperandList(newTriggerOpCon);
concept->incOperandCount();
return concept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDataRestrictionImplication(CConcept* destConcept, CDatatype* datatype, CDataLiteral* dataliteral, cint64 restrictionCode) {
CConcept* concept = createNewConcept();
concept->setOperatorCode(CCDATARESTRICTIONIMPLI);
concept->setDatatype(datatype);
concept->setDataLiteral(dataliteral);
concept->setParameter(restrictionCode);
CSortedNegLinker* newTriggerOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newTriggerOpCon->init(destConcept, false);
concept->setOperandList(newTriggerOpCon);
concept->incOperandCount();
return concept;
}
CRole* CTriggeredImplicationBinaryAbsorberPreProcess::getInverseRole(CRole* role) {
CSortedNegLinker* eqInvRoleIt = role->getInverseEquivalentRoleList();
while (eqInvRoleIt) {
if (eqInvRoleIt->isNegated()) {
return eqInvRoleIt->getData();
}
eqInvRoleIt = eqInvRoleIt->getNext();
}
CSortedNegLinker* superRoleIt = role->getIndirectSuperRoleList();
while (superRoleIt) {
if (superRoleIt->isNegated()) {
CRole* superRole = superRoleIt->getData();
CSortedNegLinker* superRoleSuperRoleIt = superRole->getIndirectSuperRoleList();
while (superRoleSuperRoleIt) {
if (superRoleSuperRoleIt->isNegated() && superRoleSuperRoleIt->getData() == role) {
return superRole;
}
superRoleSuperRoleIt = superRoleSuperRoleIt->getNext();
}
}
superRoleIt = superRoleIt->getNext();
}
// create inverse role
CRole* invRole = CConcreteOntologyInverseRoleBuilder::createInverseRoleDelayed(role,&mRoleInverseRoleCreateHash,mOnto);
++mStatInvRolesGenerated;
return invRole;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createEquivalenceAbsorbedTriggeredImplication(CConcept* eqConcept, bool negated, CSortedNegLinker* absorpOpLinker) {
CConceptTriggerLinker* triggers = nullptr;
for (CSortedNegLinker* opConLinkerIt = absorpOpLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* concept = opConLinkerIt->getData();
bool negated = opConLinkerIt->isNegated();
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept,negated));
if (tmpTriggers) {
triggers = tmpTriggers->append(triggers);
}
}
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
addUnfoldingConceptForConcept(impliedConceptTrigger->getTriggerConcept(),eqConcept,false);
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getEquivalenceConceptCandidateTriggeredImplication(CConcept* eqConcept, bool negated) {
CConcept* triggeredConcept = nullptr;
cint64 opCode = eqConcept->getOperatorCode();
if (!negated && opCode == CCEQ) {
QList candList;
if (addAbsorbableDisjunctCandidates(eqConcept,!negated,candList)) {
if (candList.count() >= 1) {
QList absorbList(getPartialAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty()) {
triggeredConcept = createPartialExtendedAbsorbedImpliedTriggerCocnept(absorbList);
}
}
}
}
return triggeredConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedTriggeredImplication(CConcept* orConcept, bool negated) {
CConcept* implicationConcept = nullptr;
cint64 opCode = orConcept->getOperatorCode();
if (!negated && opCode == CCOR || negated && opCode == CCAND) {
QList candList;
if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
if (candList.count() >= 1) {
QList absorbList(splitAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty()) {
implicationConcept = createDisjunctionAbsorbedTriggeredImplication(orConcept,negated,absorbList,candList);
}
}
}
}
return implicationConcept;
}
CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::createCardinalityQualificationPartialAbsorbedTriggers(CConcept* cardConcept, bool negated) {
CConceptRoleBranchingTrigger* branchTriggers = nullptr;
QSet conceptEqConAbsorbed;
for (CSortedNegLinker* opConLinker = cardConcept->getOperandList(); opConLinker; opConLinker = opConLinker->getNext()) {
CConcept* concept = opConLinker->getData();
bool negated = opConLinker->isNegated();
if (isConceptPartialImplicationTriggerable(concept,!negated,&conceptEqConAbsorbed)) {
CConceptRoleBranchingTrigger* tmpBranchTrigger = getSimpleBranchTriggersForConcept(concept,negated);
if (tmpBranchTrigger) {
branchTriggers = tmpBranchTrigger->append(branchTriggers);
} else {
CConceptRoleBranchingTrigger* tmpBranchTrigger = getBranchTiggers(getPartialTriggersForConcept(concept,negated));
branchTriggers = tmpBranchTrigger->append(branchTriggers);
}
}
}
return branchTriggers;
}
CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionPartialAbsorbedBranchTriggers(CConcept* orConcept, bool negated) {
CConceptRoleBranchingTrigger* branchTriggers = nullptr;
cint64 opCode = orConcept->getOperatorCode();
if (!negated && opCode == CCOR || negated && (opCode == CCAND)) {
QList candList;
if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
if (candList.count() >= 1) {
QList absorbList(getPartialAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty()) {
branchTriggers = createDisjunctionPartialAbsorbedBranchTriggers(orConcept,negated,absorbList);
}
}
}
}
return branchTriggers;
}
CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionPartialAbsorbedBranchTriggers(CConcept* orConcept, bool negated, const QList& absorbList) {
CConceptRoleBranchingTrigger* branchTriggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptRoleBranchingTrigger* tmpBranchTrigger = getSimpleBranchTriggersForConcept(concept,!negated);
if (tmpBranchTrigger) {
branchTriggers = tmpBranchTrigger->append(branchTriggers);
} else {
CConceptRoleBranchingTrigger* tmpBranchTrigger = getBranchTiggers(getPartialTriggersForConcept(concept,!negated));
branchTriggers = tmpBranchTrigger->append(branchTriggers);
}
}
return branchTriggers;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::createConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension) {
bool absorbed = false;
bool propagationActivationAbsorbable = isConceptPropagationTriggerable(intConcept, negated);
if (propagationActivationAbsorbable) {
return createPropagationConceptOfInterestAbsorption(intConcept, negated, continuationExtension);
} else {
return createDirectConceptOfInterestAbsorption(intConcept, negated, continuationExtension);
}
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::createPropagationConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension) {
TConceptNegPair intConceptNegationPair = TConceptNegPair(intConcept, negated);
CConcept* candidateBackPropTriggerCon = nullptr;
QHash conceptEqConAbsorbed;
bool completlyAbsorbable = isConceptImplicationTriggerable(intConcept, negated, &conceptEqConAbsorbed);
bool partiallyAbsorbable = completlyAbsorbable;
if (!partiallyAbsorbable) {
QSet conceptEqConPartialAbsorbed;
partiallyAbsorbable = isConceptPartialImplicationTriggerable(intConcept, negated, &conceptEqConPartialAbsorbed);
}
CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](TConceptNegPair(intConcept, negated));
CConcept* markerConcept = createMarkerConcept();
CConceptTriggerLinker* triggers = getPropagationTriggersForConcept(intConcept, negated, intConceptNegationPair, completlyAbsorbable);
if (triggers->hasNext()) {
triggers = getImplicationTriggeredConceptForTriggers(triggers, nullptr);
}
CConcept* triggerConcept = triggers->getTriggerConcept();
addUnfoldingConceptForConcept(triggerConcept, markerConcept, false);
if (completlyAbsorbable) {
mTBox->getTriggerConceptOfInterestHash()->insert(markerConcept, intConceptNegationPair);
activationTriggeringData.setTriggeringConcept(markerConcept);
} else {
mTBox->getCandidateConceptOfInterestHash()->insert(markerConcept, intConceptNegationPair);
activationTriggeringData.setCandidateConcept(markerConcept);
}
return true;
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getPropagationTriggersForConceptOperandList(CSortedNegLinker* opConLinker, bool operandsNegation, bool chooseInsteadOfNegation, CConcept* concept, bool negated, TConceptNegPair& intConceptNegationPair, bool completelyAbsorbable) {
CConceptTriggerLinker* triggers = nullptr;
QList propagationAbsorptionList;
QList backpropagationAbsorptionList;
for (CSortedNegLinker* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated();
if (!chooseInsteadOfNegation && operandsNegation) {
opNegated = !opNegated;
}
TConceptNegPair conceptNegationPair(opConcept, opNegated);
if (!chooseInsteadOfNegation || operandsNegation == opNegated) {
if (isConceptPropagationTriggerable(opConcept, opNegated)) {
propagationAbsorptionList.append(conceptNegationPair);
} else {
backpropagationAbsorptionList.append(conceptNegationPair);
}
}
}
CConceptTriggerLinker* propagationTriggers = nullptr;
for (TConceptNegationPair conceptNegationPair : propagationAbsorptionList) {
CConcept* opConcept = conceptNegationPair.first;
bool opNegated = conceptNegationPair.second;
CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPropagationTriggersForConcept(opConcept, opNegated, intConceptNegationPair, completelyAbsorbable));
propagationTriggers = newTriggers->append(propagationTriggers);
}
CConceptTriggerLinker* implPropagationTriggeredConceptLinker = nullptr;
if (propagationTriggers->hasNext()) {
implPropagationTriggeredConceptLinker = getImplicationTriggeredConceptForTriggers(propagationTriggers, nullptr);
} else {
implPropagationTriggeredConceptLinker = propagationTriggers;
}
CConcept* backPropConcept = implPropagationTriggeredConceptLinker->getTriggerConcept();
CConceptTriggerLinker* backPropTriggers = implPropagationTriggeredConceptLinker;
for (TConceptNegationPair conceptNegationPair : backpropagationAbsorptionList) {
CConcept* opConcept = conceptNegationPair.first;
bool opNegated = conceptNegationPair.second;
CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPartialTriggersForConcept(opConcept, opNegated, implPropagationTriggeredConceptLinker->getTriggerConcept()));
backPropTriggers = newTriggers->append(backPropTriggers);
}
if (backPropTriggers) {
if (!backPropTriggers->hasNext()) {
triggers = backPropTriggers;
} else {
triggers = getImplicationTriggeredConceptForTriggers(backPropTriggers, nullptr);
}
} else {
triggers = implPropagationTriggeredConceptLinker;
}
return triggers;
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getPropagationTriggersForConcept(CConcept* concept, bool negated, TConceptNegPair& intConceptNegationPair, bool completelyAbsorbable) {
CConceptTriggerLinker* triggers = nullptr;
TConceptNegationPair conNegPair(concept, negated);
cint64 opCode = concept->getOperatorCode();
cint64 parm = concept->getParameter();
cint64 opCount = concept->getOperandCount();
CRole* role = concept->getRole();
CSortedNegLinker* opConLinker = concept->getOperandList();
if (!negated && (opCode == CCNOMINAL)) {
CIndividual* nominalIndi = concept->getNominalIndividual();
CConcept* individualActivationTriggerCon = createTriggerConcept(true);
CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](intConceptNegationPair);
CConceptOfInterestActivationLinker* activationLinker = CObjectAllocator::allocateAndConstruct(mMemMan);
activationLinker->initConceptOfInterestActivationData(individualActivationTriggerCon, nominalIndi);
activationTriggeringData.addActivationLinker(activationLinker);
CConceptTriggerLinker* newTrigger = createTriggerLinker();
newTrigger->initConceptTriggerLinker(individualActivationTriggerCon, 1);
triggers = newTrigger->append(triggers);
} else if (!negated && (opCode == CCVALUE)) {
CIndividual* nominalIndi = concept->getNominalIndividual();
CRole* role = concept->getRole();
CConcept* propagatedTriggerConcept = createTriggerConcept(true);
CConcept* individualActivationTriggerCon = createTriggerPropagationConcept(propagatedTriggerConcept, role, true);
CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](intConceptNegationPair);
CConceptOfInterestActivationLinker* activationLinker = CObjectAllocator::allocateAndConstruct(mMemMan);
activationLinker->initConceptOfInterestActivationData(individualActivationTriggerCon, nominalIndi);
activationTriggeringData.addActivationLinker(activationLinker);
CConceptTriggerLinker* newTrigger = createTriggerLinker();
newTrigger->initConceptTriggerLinker(propagatedTriggerConcept, 2);
triggers = newTrigger->append(triggers);
} else if (negated && (opCode == CCOR) || !negated && (opCode == CCAND)) {
// AND, collect triggers from operands
CConceptTriggerLinker* andTriggers = getPropagationTriggersForConceptOperandList(opConLinker, negated, false, concept, negated, intConceptNegationPair, completelyAbsorbable);
triggers = andTriggers->append(triggers);
} else if (opCode == CCAQCHOOCE) {
CConceptTriggerLinker* andTriggers = getPropagationTriggersForConceptOperandList(opConLinker, negated, true, concept, negated, intConceptNegationPair, completelyAbsorbable);
triggers = andTriggers->append(triggers);
} else if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL) ||
!negated && (opCode == CCATLEAST && parm == 1) || negated && (opCode == CCATMOST && parm == 0)) {
cint64 triggerComplexity = 1;
bool negateOperands = negated && (opCode == CCSOME || opCode == CCALL);
CConceptTriggerLinker* succTriggers = getPropagationTriggersForConceptOperandList(opConLinker, negateOperands, false, concept, negated, intConceptNegationPair, completelyAbsorbable);
CConcept* rolePropagatedCon = createTriggerConcept(true);
CConcept* rolePropagationCon = createTriggerPropagationConcept(rolePropagatedCon, role, true);
addUnfoldingConceptForConcept(succTriggers->getTriggerConcept(), rolePropagationCon, false);
triggerComplexity += succTriggers->getTriggerComplexity();
CConceptTriggerLinker* newTrigger = createTriggerLinker();
newTrigger->initConceptTriggerLinker(rolePropagatedCon, triggerComplexity);
triggers = newTrigger->append(triggers);
}
return triggers;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::createDirectConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension) {
bool absorbed = false;
CConcept* candidateBackPropTriggerCon = nullptr;
QHash conceptEqConAbsorbed;
QSet conceptEqConPartialAbsorbed;
bool completlyAbsorbable = isConceptImplicationTriggerable(intConcept, negated, &conceptEqConAbsorbed);
bool partiallyAbsorbable = completlyAbsorbable;
if (!partiallyAbsorbable) {
partiallyAbsorbable = isConceptPartialImplicationTriggerable(intConcept, negated, &conceptEqConPartialAbsorbed);
}
CConcept* markerConcept = nullptr;
if (partiallyAbsorbable) {
markerConcept = createMarkerConcept();
}
CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](TConceptNegPair(intConcept, negated));
if (continuationExtension && partiallyAbsorbable) {
candidateBackPropTriggerCon = createTriggerConcept(true);
CConceptOfInterestActivationLinker* activationLinker = CObjectAllocator::allocateAndConstruct(mMemMan);
activationLinker->initConceptOfInterestActivationData(candidateBackPropTriggerCon);
activationTriggeringData.addActivationLinker(activationLinker);
absorbed = true;
}
if (completlyAbsorbable) {
CConcept* triggerConcept = getConceptOfInterestTrigger(intConcept, negated, candidateBackPropTriggerCon);
addUnfoldingConceptForConcept(triggerConcept, markerConcept, false);
mTBox->getTriggerConceptOfInterestHash()->insert(markerConcept, TConceptNegPair(intConcept, negated));
activationTriggeringData.setTriggeringConcept(markerConcept);
absorbed = true;
} else if (partiallyAbsorbable) {
CConcept* candidateConcept = getConceptOfInterestCandidate(intConcept, negated, candidateBackPropTriggerCon);
addUnfoldingConceptForConcept(candidateConcept, markerConcept, false);
activationTriggeringData.setCandidateConcept(markerConcept);
mTBox->getCandidateConceptOfInterestHash()->insert(markerConcept, TConceptNegPair(intConcept, negated));
absorbed = true;
}
return absorbed;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptPropagationTriggerable(CConcept* concept, bool negated) {
TConceptNegationPair conNegPair(concept, negated);
if (mConceptPropagationAbsorbableHash.contains(conNegPair)) {
return mConceptPropagationAbsorbableHash.value(conNegPair);
}
cint64 opCode = concept->getOperatorCode();
cint64 parm = concept->getParameter();
cint64 opCount = concept->getOperandCount();
CSortedNegLinker* opConLinker = concept->getOperandList();
bool absorbable = false;
if (!negated && (opCode == CCNOMINAL)) {
absorbable = true;
} else if (!negated && (opCode == CCVALUE)) {
absorbable = true;
} else if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL)) {
if (!opConLinker) {
absorbable = false;
} else {
bool oneOpTriggerable = false;
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt && !oneOpTriggerable) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated() ^ negated;
oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
opConLinkerIt = opConLinkerIt->getNext();
}
absorbable = oneOpTriggerable;
}
} else if (!negated && (opCode == CCATLEAST && parm == 1) || negated && (opCode == CCATMOST && parm == 0)) {
if (!opConLinker) {
absorbable = false;
} else {
bool oneOpTriggerable = true;
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt && !oneOpTriggerable) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated();
oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
opConLinkerIt = opConLinkerIt->getNext();
}
absorbable = oneOpTriggerable;
}
} else if (opCode == CCAQCHOOCE) {
bool oneOpTriggerable = false;
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt && !oneOpTriggerable) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated();
if (opNegated == negated) {
oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
}
opConLinkerIt = opConLinkerIt->getNext();
}
absorbable = oneOpTriggerable;
} else if (!negated && opCode == CCAND || negated && opCode == CCOR) {
bool oneOpTriggerable = false;
CSortedNegLinker* opConLinkerIt = opConLinker;
while (opConLinkerIt && !oneOpTriggerable) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated() ^ negated;
oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
opConLinkerIt = opConLinkerIt->getNext();
}
absorbable = oneOpTriggerable;
} else {
absorbable = false;
}
mConceptPropagationAbsorbableHash.insert(conNegPair, absorbable);
return absorbable;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedBackpropagationTriggeredImplication(CConcept* orConcept, bool negated, CConcept* backPropTriggerCon) {
CConcept* implicationConcept = nullptr;
cint64 opCode = orConcept->getOperatorCode();
if (!negated && opCode == CCOR || negated && opCode == CCAND) {
QList candList;
if (addAbsorbableDisjunctCandidates(orConcept, negated, candList)) {
if (candList.count() >= 1) {
QList absorbList(splitAbsorbableDisjuncts(candList));
QList partialAbsorbList(getPartialAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty() || !partialAbsorbList.isEmpty()) {
implicationConcept = createDisjunctionAbsorbedBackpropagationTriggeredImplication(orConcept, negated, absorbList, partialAbsorbList, candList, backPropTriggerCon);
}
}
}
}
return implicationConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedBackpropagationTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& partialAbsorbList, QList& candList, CConcept* backPropTriggerCon) {
CConcept* impliedConcept = nullptr;
CConcept* implicationConcept = nullptr;
bool impliedNegation = false;
if (candList.isEmpty()) {
candList.append(absorbList.takeFirst());
}
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept, !negated, backPropTriggerCon));
triggers = tmpTriggers->append(triggers);
}
for (QList::const_iterator it = partialAbsorbList.constBegin(), itEnd = partialAbsorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept, !negated, backPropTriggerCon));
triggers = tmpTriggers->append(triggers);
}
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, &implicationConcept);
impliedConcept = impliedConceptTrigger->getTriggerConcept();
if (candList.count() > 1) {
CConcept* orImpliedConcept = createImpliedConcept();
for (QList::const_iterator it = candList.constBegin(), itEnd = candList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
addConceptToImplied(orImpliedConcept, concept, negated);
}
orImpliedConcept->setOperatorCode(CCOR);
mCreatedImpliedDisjunctions.insert(orImpliedConcept);
addUnfoldingConceptForConcept(impliedConcept, orImpliedConcept, false);
} else {
TConceptNegationPair conNegPair(candList.first());
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
addUnfoldingConceptForConcept(impliedConcept, concept, negated);
}
return implicationConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialBackpropagationExtendedAbsorbedImpliedTriggerCocnept(const QList& absorbList, CConcept* backPropTriggerCon) {
CConceptTriggerLinker* trigger = createPartialBackpropagationExtendedAbsorbedImpliedTrigger(absorbList, backPropTriggerCon);
if (trigger) {
return trigger->getTriggerConcept();
}
return nullptr;
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialBackpropagationExtendedAbsorbedImpliedTrigger(const QList& absorbList, CConcept* backPropTriggerCon) {
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept, !negated, backPropTriggerCon));
triggers = tmpTriggers->append(triggers);
}
CConcept* implicationConcept = nullptr;
CConcept** implicationConceptPointer = nullptr;
if (backPropTriggerCon) {
implicationConceptPointer = &implicationConcept;
}
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, implicationConceptPointer);
if (implicationConcept) {
addUnfoldingConceptForConcept(backPropTriggerCon, implicationConcept, false);
}
return impliedConceptTrigger;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getConceptOfInterestCandidate(CConcept* intConcept, bool negated, CConcept* backPropTriggerCon) {
CConcept* triggeredConcept = nullptr;
QList candList;
if (addAbsorbableDisjunctCandidates(intConcept, !negated, candList)) {
if (candList.count() >= 1) {
QList absorbList(getPartialAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty()) {
triggeredConcept = createBackpropPartialExtendedAbsorbedImpliedTrigger(absorbList, backPropTriggerCon)->getTriggerConcept();
}
}
}
return triggeredConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getConceptOfInterestTrigger(CConcept* intConcept, bool negated, CConcept* backPropTriggerCon) {
CConcept* triggeredConcept = nullptr;
QList candList;
if (addAbsorbableDisjunctCandidates(intConcept, !negated, candList)) {
if (candList.count() >= 1) {
QList absorbList(splitAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty()) {
triggeredConcept = createBackpropExtendedAbsorbedImpliedTrigger(absorbList, backPropTriggerCon)->getTriggerConcept();
}
}
}
return triggeredConcept;
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createBackpropPartialExtendedAbsorbedImpliedTrigger(const QList& absorbList, CConcept* backPropTriggerCon) {
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept, !negated, backPropTriggerCon));
triggers = tmpTriggers->append(triggers);
}
CConcept* backPropImpConcept = nullptr;
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, &backPropImpConcept);
addUnfoldingConceptForConcept(backPropTriggerCon, backPropImpConcept, false);
return impliedConceptTrigger;
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createBackpropExtendedAbsorbedImpliedTrigger(const QList& absorbList, CConcept* backPropTriggerCon) {
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept, !negated, backPropTriggerCon));
triggers = tmpTriggers->append(triggers);
}
CConcept* backPropImpConcept = nullptr;
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, &backPropImpConcept);
addUnfoldingConceptForConcept(backPropTriggerCon, backPropImpConcept, false);
return impliedConceptTrigger;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbPartialGCIConceptsToTriggeredImplications(CConcept* orConcept, bool negated) {
cint64 opCode = orConcept->getOperatorCode();
if (!negated && opCode == CCOR || negated && opCode == CCAND) {
QList candList;
if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
if (candList.count() >= 1) {
QList absorbList(getPartialAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty()) {
createGCIPartialAbsorbedTriggeredImplication(orConcept,negated,absorbList);
if (absorbList.count() + 1 == candList.count()) {
QList assurList(getAssuringAbsorbableDisjuncts(absorbList));
if (assurList.count() == absorbList.count()) {
createGCIAssuringAbsorbedTriggeredImplication(orConcept, negated, assurList, candList);
}
}
return true;
}
}
}
}
return false;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createGCIAssuringAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, const QList& absorbList, const QList& disjList) {
CConcept* remainingDisConcept = nullptr;
bool remainingDisConNegation = false;
QSet absorbDisjSet = absorbList.toSet();
for (TConceptNegationPair disConNegPair : disjList) {
if (!absorbDisjSet.contains(disConNegPair)) {
remainingDisConcept = disConNegPair.first;
remainingDisConNegation = disConNegPair.second;
break;
}
}
CConceptTriggerLinker* partialImpliedTrigger = createAssuringExtendedAbsorbedImpliedTrigger(absorbList);
CConcept* partialImpliedTriggerConcept = partialImpliedTrigger->getTriggerConcept();
addUnfoldingConceptForConcept(partialImpliedTriggerConcept, remainingDisConcept, remainingDisConNegation);
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createAssuringExtendedAbsorbedImpliedTrigger(const QList& absorbList) {
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getAssuringTriggersForConcept(concept, !negated));
triggers = tmpTriggers->append(triggers);
}
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, nullptr);
return impliedConceptTrigger;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbNominalSchemaGCIConceptsToTriggeredImplications(CConcept* concept, bool negated) {
if (concept->getOperatorCode() == CCNOMTEMPLREF) {
cint64 nomSchTemplIndex = concept->getParameter();
CNominalSchemaTemplate* nsTemplate = mNomSchemaTemplVec->getData(nomSchTemplIndex);
if (nsTemplate) {
CConcept* templConcept = nsTemplate->getTemplateConcept();
cint64 opCode = templConcept->getOperatorCode();
if (!negated && opCode == CCOR || negated && opCode == CCAND) {
QList candList;
if (addAbsorbableDisjunctCandidates(templConcept,negated,candList)) {
if (candList.count() >= 1) {
QList absorbList(splitAbsorbableDisjuncts(candList));
QList partialAbsorbList(getPartialAbsorbableDisjuncts(candList));
if (!absorbList.isEmpty() || !partialAbsorbList.isEmpty()) {
createGCINominalSchemaAbsorbedTriggeredImplication(templConcept,negated,absorbList,partialAbsorbList,candList,nsTemplate);
return true;
}
}
}
}
}
}
return false;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbNominalConceptsToAssertions(CConcept* orConcept, bool negated) {
bool absorbed = false;
cint64 opCode = orConcept->getOperatorCode();
if (!negated && opCode == CCOR || negated && opCode == CCAND) {
if (orConcept->getOperandCount() == 2) {
CConcept* nominalCon = orConcept->getOperandList()->getData();
bool nominalConNeg = orConcept->getOperandList()->isNegated() ^ negated;
CConcept* impliedCon = orConcept->getOperandList()->getNext()->getData();
bool impliedConNeg = orConcept->getOperandList()->getNext()->isNegated() ^ negated;
if (!nominalConNeg || nominalCon->getOperatorCode() != CCNOMINAL) {
CConcept* tmpCon = nominalCon;
bool tmpConNeg = nominalConNeg;
nominalCon = impliedCon;
nominalConNeg = impliedConNeg;
impliedCon = tmpCon;
impliedConNeg = tmpConNeg;
}
if (nominalConNeg && nominalCon->getOperatorCode() == CCNOMINAL) {
CIndividual* nomIndi = nominalCon->getNominalIndividual();
cint64 impliedConCode = impliedCon->getOperatorCode();
if (!impliedConNeg && impliedConCode == CCSOME && impliedCon->getOperandCount() == 1) {
CConcept* someQuantifiedCon = impliedCon->getOperandList()->getData();
bool someQuantifiedConNeg = impliedCon->getOperandList()->isNegated() ^ impliedConNeg;
cint64 someQuantifiedConCode = someQuantifiedCon->getOperatorCode();
if (!someQuantifiedConNeg && someQuantifiedConCode == CCNOMINAL) {
absorbed = true;
// absorb as role assertion
CIndividual* connNomIndi = someQuantifiedCon->getNominalIndividual();
CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(nomIndi, mOnto);
CRoleAssertionLinker* roleAssLinker = CObjectAllocator< CRoleAssertionLinker >::allocateAndConstruct(mMemMan);
roleAssLinker->initRoleAssertionLinker(impliedCon->getRole(), connNomIndi);
locatedIndividual->addAssertionRoleLinker(roleAssLinker);
}
}
if (!absorbed) {
absorbed = true;
// absorb as concept assertion
CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(nomIndi, mOnto);
CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
assLinker->initNegLinker(impliedCon, impliedConNeg);
locatedIndividual->addAssertionConceptLinker(assLinker);
}
}
}
}
return absorbed;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbNegatedSelfToRoleDomain(CConcept* concept, bool negated) {
bool absorbed = false;
cint64 opCode = concept->getOperatorCode();
if (negated && opCode == CCSELF) {
CRole* role = concept->getRole();
CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role, mOnto);
CSortedNegLinker* domainConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
domainConLinker->init(concept, true);
locatedRole->addDomainConceptLinker(domainConLinker);
absorbed = true;
}
return absorbed;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createGCINominalSchemaAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& partialAbsorbList, QList& candList, CNominalSchemaTemplate* nsTemplate) {
CConcept* impliedConcept = nullptr;
bool impliedNegation = false;
QList partialAbsorbableList;
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,!negated));
triggers = tmpTriggers->append(triggers);
}
for (QList::const_iterator it = partialAbsorbList.constBegin(), itEnd = partialAbsorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,!negated));
triggers = tmpTriggers->append(triggers);
}
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
impliedConcept = impliedConceptTrigger->getTriggerConcept();
QList absorpConceptList(absorbList);
absorpConceptList.append(partialAbsorbList);
QSet conceptSet;
for (QList::const_iterator it = absorpConceptList.constBegin(), itEnd = absorpConceptList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* operandConcept = conNegPair.first;
bool operandConceptNegation = conNegPair.second;
conceptSet.insert(TConceptNegationPair(operandConcept,!operandConceptNegation));
}
QHash nomSchConceptVariableHash;
CBOXSET* nominalSchemasSet = nsTemplate->getNominalSchemaConceptSet();
for (CBOXSET::const_iterator it = nominalSchemasSet->constBegin(), itEnd = nominalSchemasSet->constEnd(); it != itEnd; ++it) {
CConcept* nominalSchemaConcept = *it;
CVariable* variable = CObjectAllocator< CVariable >::allocateAndConstruct(mMemMan);
variable->initVariable(nominalSchemaConcept,mNextVariableID++);
nomSchConceptVariableHash.insert(nominalSchemaConcept,variable);
}
QList groundConceptList(candList);
CConcept* nextAbsorptionConcept = impliedConcept;
bool pathPreabsorption = false;
if (mConfNominalSchemaPathPreabsorption) {
if (nominalSchemasSet->count() >= 3) {
pathPreabsorption = true;
}
}
if (pathPreabsorption) {
// create nominal schema absorption path
CNominalSchemaAbsorptionPathLinker* absorptionPathLinker = new CNominalSchemaAbsorptionPathLinker();
absorptionPathLinker->initNominalSchemaAbsorptionPathLinker(nullptr);
absorptionPathLinker->setLastPathTriggerConcept(nextAbsorptionConcept);
absorptionPathLinker = getAbsorbedNominalSchemaPaths(conceptSet,absorptionPathLinker,&nomSchConceptVariableHash,nsTemplate);
nextAbsorptionConcept = createBindingBackPropagationTriggerConcept();
for (CNominalSchemaAbsorptionPathLinker* absorptionPathLinkerIt = absorptionPathLinker; absorptionPathLinkerIt; absorptionPathLinkerIt = absorptionPathLinkerIt->getNext()) {
CConcept* groundingConcept = nullptr;
bool groundingConNegation = false;
CNominalSchemaTemplate* grNSTemplate = nsTemplate;
createBindingGroundConcept(groundingConcept,groundingConNegation,groundConceptList,grNSTemplate,CCPBINDGROUND);
CConcept* lastPathTriggerConcept = absorptionPathLinkerIt->getLastPathTriggerConcept();
addConceptOperand(lastPathTriggerConcept,groundingConcept,groundingConNegation);
addConceptOperand(groundingConcept,nextAbsorptionConcept,false);
}
} else {
CConcept* tmpNextAbsorptionConcept = createBindingBackPropagationActivationTriggerConcept();
addConceptOperand(nextAbsorptionConcept,tmpNextAbsorptionConcept,false);
nextAbsorptionConcept = tmpNextAbsorptionConcept;
}
CNominalSchemaAbsorptionBranchLinker* absorptionBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(conceptSet,nextAbsorptionConcept,&nomSchConceptVariableHash,nsTemplate);
for (CNominalSchemaAbsorptionBranchLinker* absorptionBranchLinkerIt = absorptionBranchLinker; absorptionBranchLinkerIt; absorptionBranchLinkerIt = absorptionBranchLinkerIt->getNext()) {
CConcept* groundingConcept = nullptr;
bool groundingConNegation = false;
CNominalSchemaTemplate* grNSTemplate = nsTemplate;
createBindingGroundConcept(groundingConcept,groundingConNegation,groundConceptList,grNSTemplate,CCVARBINDGROUND);
CConcept* lastPathTriggerConcept = absorptionBranchLinkerIt->getLastBranchTriggerConcept();
addConceptOperand(lastPathTriggerConcept,groundingConcept,groundingConNegation);
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createBindingGroundConcept(CConcept*& groundingConcept, bool& groundingConNegation, const QList& groundConceptList, CNominalSchemaTemplate* nsTemplate, cint64 groundOpCode) {
CConcept* groundConcept = nullptr;
bool groundConNegation = false;
bool createNewTemplate = false;
if (groundConceptList.count() > 1) {
CConcept* orConcept = createNewConcept();
orConcept->setOperatorCode(CCOR);
for (QList::const_iterator it = groundConceptList.constBegin(), itEnd = groundConceptList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* operandConcept = conNegPair.first;
bool operandConceptNegation = conNegPair.second;
addConceptOperand(orConcept,operandConcept,operandConceptNegation);
}
groundConcept = orConcept;
groundConNegation = false;
createNewTemplate = true;
} else if (groundConceptList.count() == 1) {
TConceptNegationPair conNegPair(groundConceptList.first());
groundConcept = conNegPair.first;
groundConNegation = conNegPair.second;
createNewTemplate = true;
} else {
groundConcept = mTopConcept;
groundConNegation = true;
}
if (createNewTemplate) {
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 (!mNomSchemaTemplVec) {
mNomSchemaTemplVec = mMBox->getNominalSchemaTemplateVector();
}
cint64 nextNomSchTemplID = mNomSchemaTemplVec->getItemCount();
nsTemplate->setNominalSchemaTemplateTag(nextNomSchTemplID);
mNomSchemaTemplVec->setData(nextNomSchTemplID,nsTemplate);
nsTemplate->setTemplateConcept(groundConcept);
collectNominalSchemaConcepts(groundConcept,nominalSchemaConceptSet);
FOREACHIT (CConcept* nomSchConcept, *nominalSchemaConceptSet) {
QSet testedNomSchemConSet;
hasNominalSchemaConceptFillHash(groundConcept,conceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemConSet);
QSet testedNomSchemAbsorbedConSet;
hasNominalSchemaAbsorbableConceptFillHash(groundConcept,groundingConNegation,absorbableConceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemAbsorbedConSet);
}
groundingConcept = createBindingGroundingConcept(nsTemplate,groundOpCode);
} else {
groundingConcept = groundConcept;
}
groundingConNegation = groundConNegation;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::hasNominalSchemaAbsorbableConceptFillHash(CConcept* concept, bool negation, CBOXHASH* absorbableConceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet* testedConceptSet) {
cint64 conOpCode = concept->getOperatorCode();
if (conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
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 CTriggeredImplicationBinaryAbsorberPreProcess::hasNominalSchemaConceptFillHash(CConcept* concept, CBOXHASH* conceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet* testedConceptSet) {
cint64 conOpCode = concept->getOperatorCode();
if (conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
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 CTriggeredImplicationBinaryAbsorberPreProcess::collectNominalSchemaConcepts(CConcept* concept, CBOXSET* nominalSchemaConceptSet) {
cint64 conOpCode = concept->getOperatorCode();
if (conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
} else if (conOpCode == CCNOMVAR) {
nominalSchemaConceptSet->insert(concept);
} else {
for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
collectNominalSchemaConcepts(opConcept,nominalSchemaConceptSet);
}
}
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingGroundingConcept(CNominalSchemaTemplate* nsTemplate, cint64 groundOpCode) {
CConcept* groundingConcept = createNewConcept();
groundingConcept->setOperatorCode(groundOpCode);
groundingConcept->setParameter(nsTemplate->getNominalSchemaTemplateTag());
return groundingConcept;
}
CNominalSchemaAbsorptionPathLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedNominalSchemaPaths(const QSet& conceptSet, CNominalSchemaAbsorptionPathLinker* absorptionPathLinker, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
CConceptTriggerLinker* triggers = nullptr;
QSet conceptEqConAbsorbed;
QSet relatedConceptSet;
for (QSet::const_iterator it = conceptSet.constBegin(), itEnd = conceptSet.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
collectNominalSchemaRelatedConcepts(concept,negated,relatedConceptSet,nsTemplate);
isConceptPartialImplicationTriggerable(concept,negated,&conceptEqConAbsorbed);
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,negated));
if (tmpTriggers) {
triggers = tmpTriggers->append(triggers);
}
}
QList nomSchConList;
QList otherConList;
QList orConList;
sortNominalSchemaRelatedConcepts(relatedConceptSet,nsTemplate,nomSchConList,otherConList,orConList);
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
CConcept* triggerConcept = impliedConceptTrigger->getTriggerConcept();
CNominalSchemaAbsorptionPathLinker* newAbsorptionPathLinker = nullptr;
CNominalSchemaAbsorptionPathLinker* absorptionPathLinkerIt = absorptionPathLinker;
while (absorptionPathLinkerIt) {
CNominalSchemaAbsorptionPathLinker* absorptionPath = absorptionPathLinkerIt;
absorptionPathLinkerIt = absorptionPathLinkerIt->getNext();
absorptionPath->clearNext();
CConcept* lastPathTriggerConcept = absorptionPath->getLastPathTriggerConcept();
QList initNomSchConList;
CConcept* levelTriggerConcept = nullptr;
if (triggerConcept != lastPathTriggerConcept) {
CConcept* nextPathTriggerConcept = createBindingTriggerConcept();
CConcept* implicationConcept = createBindingImplicationTriggeredConcept(triggerConcept,nextPathTriggerConcept);
addConceptOperand(lastPathTriggerConcept,implicationConcept,false);
lastPathTriggerConcept = nextPathTriggerConcept;
}
// find already binded nominal schema variables
QHash* nomSchConTrigHash = absorptionPath->getNominalSchemaBindedConceptTriggerHash();
for (QList::const_iterator it = nomSchConList.constBegin(), itEnd = nomSchConList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair nomSchConNegPair(*it);
CConcept* nomSchConcept = nomSchConNegPair.first;
CConcept* nominalBindConceptTrigger = nomSchConTrigHash->value(nomSchConcept,nullptr);
if (nominalBindConceptTrigger) {
CConcept* nextPathTriggerConcept = createBindingTriggerConcept();
if (!levelTriggerConcept) {
levelTriggerConcept = nominalBindConceptTrigger;
}
CConcept* cycleCloseConcept = createBindingCycleCloseConcept(nominalBindConceptTrigger,nextPathTriggerConcept);
addConceptOperand(lastPathTriggerConcept,cycleCloseConcept,false);
lastPathTriggerConcept = nextPathTriggerConcept;
} else {
initNomSchConList.append(nomSchConNegPair);
}
}
//if (!levelTriggerConcept) {
// levelTriggerConcept = createBindingTriggerConcept();
// cint64 nextVariableID = 0;
// if (absorptionPath->hasVariables()) {
// nextVariableID = absorptionPath->getLastVariable()->getPathVariableID()+1;
// }
// CConcept* nominalConcept = nullptr;
// if (!initNomSchConList.isEmpty()) {
// TConceptNegationPair nomSchConNegPair(initNomSchConList.first());
// CConcept* nomSchConcept = nomSchConNegPair.first;
// nominalConcept = nomSchConcept;
// }
// CVariable* variable = CObjectAllocator< CVariable >::allocateAndConstruct(mMemMan);
// variable->initVariable(nominalConcept,nextVariableID);
// absorptionPath->addVariable(variable);
// CConcept* varBindConcept = createBindingVariableConcept(levelTriggerConcept,variable);
// addConceptOperand(lastPathTriggerConcept,varBindConcept,false);
// lastPathTriggerConcept = levelTriggerConcept;
//}
for (QList::const_iterator it = initNomSchConList.constBegin(), itEnd = initNomSchConList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair nomSchConNegPair(*it);
CConcept* nomSchConcept = nomSchConNegPair.first;
CConcept* nextTriggerConcept = createBindingTriggerConcept();
CVariable* variable = nomSchConceptVariableHash->value(nomSchConcept);
absorptionPath->addVariable(variable);
CConcept* varBindConcept = createBindingVariableConcept(nextTriggerConcept,variable);
addConceptOperand(lastPathTriggerConcept,varBindConcept,false);
nomSchConTrigHash->insert(nomSchConcept,nextTriggerConcept);
lastPathTriggerConcept = nextTriggerConcept;
if (!levelTriggerConcept) {
levelTriggerConcept = nextTriggerConcept;
}
}
absorptionPath->setLastPathTriggerConcept(lastPathTriggerConcept);
// build absorption path recursive
CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinker = absorptionPath;
for (QList::const_iterator itRec = otherConList.constBegin(), itRecEnd = otherConList.constEnd(); itRec != itRecEnd; ++itRec) {
TConceptNegationPair succConNegPair(*itRec);
CConcept* succConcept = succConNegPair.first;
bool succConNegation = succConNegPair.second;
cint64 succConOpCode = succConcept->getOperatorCode();
cint64 param = succConcept->getParameter();
if (!succConNegation && (succConOpCode == CCSOME || succConOpCode == CCATLEAST && param == 1) || succConNegation && (succConOpCode == CCALL || succConOpCode == CCATMOST && param == 0)) {
CRole* role = succConcept->getRole();
bool succOpNegate = succConOpCode == CCALL;
if (succConcept->getOperandList()) {
for (CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinkerIt = nextAbsorptionPathLinker; nextAbsorptionPathLinkerIt; nextAbsorptionPathLinkerIt = nextAbsorptionPathLinkerIt->getNext()) {
CConcept* nextAbsorptionPathTriggerConcept = createBindingTriggerConcept();
CConcept* lastAbsorptionPathTriggerConcept = nextAbsorptionPathLinkerIt->getLastPathTriggerConcept();
CConcept* propagationPathTriggerConcept = createBindingToSuccessorPropagationConcept(nextAbsorptionPathTriggerConcept,role);
addConceptOperand(lastAbsorptionPathTriggerConcept,propagationPathTriggerConcept,false);
nextAbsorptionPathLinkerIt->setLastPathTriggerConcept(nextAbsorptionPathTriggerConcept);
}
QSet operandConceptSet;
for (CSortedNegLinker* succOpConLinkerIt = succConcept->getOperandList(); succOpConLinkerIt; succOpConLinkerIt = succOpConLinkerIt->getNext()) {
CConcept* succOpCon = succOpConLinkerIt->getData();
bool succOpConNeg = succOpConLinkerIt->isNegated() ^ succOpNegate;
operandConceptSet.insert(TConceptNegationPair(succOpCon,succOpConNeg));
}
nextAbsorptionPathLinker = getAbsorbedNominalSchemaPaths(operandConceptSet,nextAbsorptionPathLinker,nomSchConceptVariableHash,nsTemplate);
for (CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinkerIt = nextAbsorptionPathLinker; nextAbsorptionPathLinkerIt; nextAbsorptionPathLinkerIt = nextAbsorptionPathLinkerIt->getNext()) {
CConcept* propNextAbsorptionPathTriggerConcept = createBindingTriggerConcept();
CConcept* lastAbsorptionPathTriggerConcept = nextAbsorptionPathLinkerIt->getLastPathTriggerConcept();
CConcept* propagationPathTriggerConcept = createBindingFromSuccessorPropagationConcept(propNextAbsorptionPathTriggerConcept,role);
addConceptOperand(lastAbsorptionPathTriggerConcept,propagationPathTriggerConcept,false);
if (levelTriggerConcept) {
CConcept* cylceNextAbsorptionPathTriggerConcept = createBindingTriggerConcept();
CConcept* cycleCloseConcept = createBindingCycleCloseConcept(levelTriggerConcept,cylceNextAbsorptionPathTriggerConcept);
addConceptOperand(propNextAbsorptionPathTriggerConcept,cycleCloseConcept,false);
nextAbsorptionPathLinkerIt->setLastPathTriggerConcept(cylceNextAbsorptionPathTriggerConcept);
} else {
nextAbsorptionPathLinkerIt->setLastPathTriggerConcept(propNextAbsorptionPathTriggerConcept);
}
}
}
}
}
for (QList::const_iterator itOr = orConList.constBegin(), itOrEnd = orConList.constEnd(); itOr != itOrEnd; ++itOr) {
TConceptNegationPair orConNegPair(*itOr);
CConcept* orConcept = orConNegPair.first;
bool orConNegation = orConNegPair.second;
cint64 orConOpCode = orConcept->getOperatorCode();
if (!orConNegation && (orConOpCode == CCOR) || orConNegation && (orConOpCode == CCAND)) {
cint64 opCount = orConcept->getOperandCount();
if (opCount > 1) {
CNominalSchemaAbsorptionPathLinker* newNextAbsorptionPathLinker = nullptr;
CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinkerIt = nextAbsorptionPathLinker;
while (nextAbsorptionPathLinkerIt) {
nextAbsorptionPathLinker = nextAbsorptionPathLinkerIt;
nextAbsorptionPathLinkerIt = nextAbsorptionPathLinkerIt->getNext();
nextAbsorptionPathLinker->clearNext();
CNominalSchemaAbsorptionPathLinker* dublicateAbsorptionPathLinkerIt = duplicateNominalSchemaAbsorptionPaths(nextAbsorptionPathLinker,opCount);
for (CSortedNegLinker* orOpConLinkerIt = orConcept->getOperandList(); orOpConLinkerIt; orOpConLinkerIt = orOpConLinkerIt->getNext()) {
CNominalSchemaAbsorptionPathLinker* dublicateAbsorptionPathLinker = dublicateAbsorptionPathLinkerIt;
dublicateAbsorptionPathLinkerIt = dublicateAbsorptionPathLinkerIt->getNext();
dublicateAbsorptionPathLinker->clearNext();
CConcept* orOpCon = orOpConLinkerIt->getData();
bool orOpConNeg = orOpConLinkerIt->isNegated();
QSet operandConceptSet;
operandConceptSet.insert(TConceptNegationPair(orOpCon,orOpConNeg));
dublicateAbsorptionPathLinker = getAbsorbedNominalSchemaPaths(operandConceptSet,dublicateAbsorptionPathLinker,nomSchConceptVariableHash,nsTemplate);
newNextAbsorptionPathLinker = dublicateAbsorptionPathLinker->append(newNextAbsorptionPathLinker);
}
}
nextAbsorptionPathLinker = newNextAbsorptionPathLinker;
}
}
}
newAbsorptionPathLinker = nextAbsorptionPathLinker->append(newAbsorptionPathLinker);
}
return newAbsorptionPathLinker;
}
CNominalSchemaAbsorptionPathLinker* CTriggeredImplicationBinaryAbsorberPreProcess::duplicateNominalSchemaAbsorptionPaths(CNominalSchemaAbsorptionPathLinker* abPathLinker, cint64 duplicateCount) {
CNominalSchemaAbsorptionPathLinker* duplicateLinker = abPathLinker;
for (cint64 i = 1; i < duplicateCount; ++i) {
CNominalSchemaAbsorptionPathLinker* linker = new CNominalSchemaAbsorptionPathLinker();
linker->initNominalSchemaAbsorptionPathLinker(abPathLinker);
duplicateLinker = linker->append(duplicateLinker);
}
return duplicateLinker;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingToSuccessorPropagationConcept(CConcept* followingConcept, CRole* role) {
CConcept* succPropConcept = createNewConcept();
succPropConcept->setOperatorCode(CCPBINDALL);
succPropConcept->setRole(role);
addConceptOperand(succPropConcept,followingConcept,false);
return succPropConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingFromSuccessorPropagationConcept(CConcept* followingConcept, CRole* role) {
CRole* inverseRole = getInverseRole(role);
CConcept* succPropConcept = createNewConcept();
succPropConcept->setOperatorCode(CCPBINDALL);
succPropConcept->setRole(inverseRole);
addConceptOperand(succPropConcept,followingConcept,false);
return succPropConcept;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::addConceptOperand(CConcept* concept, CConcept* operandConcept, bool operandNegation) {
CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon->init(operandConcept,operandNegation,concept->getOperandList());
concept->setOperandList(newBaseOpCon);
concept->incOperandCount();
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingTriggerConcept() {
CConcept* triggConcept = createNewConcept();
triggConcept->setOperatorCode(CCPBINDTRIG);
return triggConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept) {
CConcept* implicationConcept = createNewConcept();
implicationConcept->setOperatorCode(CCPBINDIMPL);
CSortedNegLinker* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon1->init(triggeredConcept,true);
CSortedNegLinker* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon2->init(impliedConcept,false,newBaseOpCon1);
implicationConcept->setOperandList(newBaseOpCon2);
implicationConcept->incOperandCount(2);
return implicationConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingCycleCloseConcept(CConcept* cycleCloseTriggerConcept, CConcept* impliedTriggerConcept) {
CConcept* cycleConcept = createNewConcept();
cycleConcept->setOperatorCode(CCPBINDCYCLE);
CSortedNegLinker* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon1->init(cycleCloseTriggerConcept,true);
CSortedNegLinker* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon2->init(impliedTriggerConcept,false,newBaseOpCon1);
cycleConcept->setOperandList(newBaseOpCon2);
cycleConcept->incOperandCount(2);
return cycleConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingVariableConcept(CConcept* followingConcept, CVariable* variable) {
CConcept* bindConcept = createNewConcept();
bindConcept->setOperatorCode(CCPBINDVARIABLE);
bindConcept->setVariableLinker(CObjectAllocator< CSortedLinker >::allocateAndConstruct(mMemMan)->init(variable));
addConceptOperand(bindConcept,followingConcept,false);
return bindConcept;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::sortNominalSchemaRelatedConcepts(QSet& conceptSet, CNominalSchemaTemplate* nsTemplate, QList& nomSchConList, QList& otherConList, QList& orConList) {
for (QSet::const_iterator it = conceptSet.constBegin(), itEnd = conceptSet.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool conNegation = conNegPair.second;
cint64 opCode = concept->getOperatorCode();
if (conNegation && (opCode == CCAND) || !conNegation && (opCode == CCOR)) {
orConList.append(conNegPair);
} else if (!conNegation && (opCode == CCNOMVAR)) {
nomSchConList.append(conNegPair);
} else {
otherConList.append(conNegPair);
}
}
}
void CTriggeredImplicationBinaryAbsorberPreProcess::collectNominalSchemaRelatedConcepts(CConcept* concept, bool negated, QSet& conceptSet, CNominalSchemaTemplate* nsTemplate) {
CBOXHASH* conceptNomSchemaAbsorbableConceptsHash = nsTemplate->getTemplateAbsorbableConceptNominalSchemaConceptHash();
if (conceptNomSchemaAbsorbableConceptsHash->contains(concept)) {
cint64 opCode = concept->getOperatorCode();
if (!negated && (opCode == CCAND) || negated && (opCode == CCOR)) {
for (CSortedNegLinker* opLinkIt = concept->getOperandList(); opLinkIt; opLinkIt = opLinkIt->getNext()) {
CConcept* opConcept = opLinkIt->getData();
bool opConNegation = opLinkIt->isNegated() ^ negated;
collectNominalSchemaRelatedConcepts(opConcept,opConNegation,conceptSet,nsTemplate);
}
} else {
conceptSet.insert(TConceptNegationPair(concept,negated));
}
}
}
CNominalSchemaAbsorptionBranchLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedJoinedNominalSchemaBranchLinker(CConcept* absorbingConcept, bool absorbingNegation, CConcept* backPropConTrigger, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
TConceptNegationPair absConNegPair(absorbingConcept,absorbingNegation);
CNominalSchemaAbsorptionBranchLinker* abBranchLinker = mConceptNomSchAbsorpBranchLinkerHash.value(absConNegPair);
if (!abBranchLinker) {
QSet relatedConceptSet;
relatedConceptSet.insert(TConceptNegationPair(absorbingConcept,absorbingNegation));
abBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(relatedConceptSet,backPropConTrigger,nomSchConceptVariableHash,nsTemplate);
mConceptNomSchAbsorpBranchLinkerHash.insert(absConNegPair,abBranchLinker);
}
return abBranchLinker;
}
CNominalSchemaAbsorptionBranchLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedJoinedNominalSchemaBranchLinker(const QSet& conceptSet, CConcept* backPropConTrigger, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
CNominalSchemaAbsorptionBranchLinker* newAbLinker = nullptr;
CConceptTriggerLinker* triggers = nullptr;
QSet relatedConceptSet;
for (QSet::const_iterator it = conceptSet.constBegin(), itEnd = conceptSet.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
collectNominalSchemaRelatedConcepts(concept,negated,relatedConceptSet,nsTemplate);
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,negated));
if (tmpTriggers) {
triggers = tmpTriggers->append(triggers);
}
}
QList nomSchConList;
QList otherConList;
QList orConList;
sortNominalSchemaRelatedConcepts(relatedConceptSet,nsTemplate,nomSchConList,otherConList,orConList);
QList allConList(otherConList);
allConList += nomSchConList;
allConList += orConList;
CConcept* triggerConcept = nullptr;
if (triggers) {
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
triggerConcept = impliedConceptTrigger->getTriggerConcept();
}
CConcept* activationTriggerConcept = nullptr;
if (!activationTriggerConcept && mConfNominalSchemaBackPropagationMultiTrigger && mConfNominalSchemaBackPropagation) {
CBackPropTrigHashData* backPropTrigHashData = nullptr;
for (QList::const_iterator nomSchIt = nomSchConList.constBegin(), nomSchItEnd = nomSchConList.constEnd(); nomSchIt != nomSchItEnd && !backPropTrigHashData; ++nomSchIt) {
CConcept* nomSchCon = nomSchIt->first;
backPropTrigHashData = mVarBackPropTrigHash.value(nomSchCon);
}
if (backPropTrigHashData) {
activationTriggerConcept = backPropTrigHashData->mActivationTriggerConcept;
if (triggerConcept) {
addBindingBackPropagationTriggeredToImplicationConcept(backPropTrigHashData->mImplicationConcept,triggerConcept);
}
addBindingBackPropagationTriggeredToImplicationConcept(backPropTrigHashData->mImplicationConcept,backPropConTrigger);
}
}
if (!activationTriggerConcept) {
activationTriggerConcept = createBindingBackPropagationTriggerConcept();
if (!mConfNominalSchemaBackPropagation && triggerConcept) {
CConcept* tmpNextAbsorptionConcept = createBindingBackPropagationActivationTriggerConcept();
addConceptOperand(triggerConcept,tmpNextAbsorptionConcept,false);
addConceptOperand(tmpNextAbsorptionConcept,activationTriggerConcept,false);
} else {
if (!triggerConcept) {
addConceptOperand(backPropConTrigger,activationTriggerConcept,false);
} else {
CConcept* implBindBackPropTrigCon = createBindingBackPropagationImplicationTriggeredConcept(triggerConcept,activationTriggerConcept);
addConceptOperand(backPropConTrigger,implBindBackPropTrigCon,false);
if (!nomSchConList.isEmpty() && mConfNominalSchemaBackPropagationMultiTrigger) {
CBackPropTrigHashData* backPropTrigHashData = new CBackPropTrigHashData(activationTriggerConcept,implBindBackPropTrigCon);
mVarBackPropTrigContainer.append(backPropTrigHashData);
foreach (TConceptNegationPair conNegPair, nomSchConList) {
CConcept* nomSchCon = conNegPair.first;
mVarBackPropTrigHash.insert(nomSchCon,backPropTrigHashData);
}
}
}
}
}
QList newBranchConList;
QList newMultiBranchConList;
QList newSingleBranchConList;
for (QList::const_iterator itRec = allConList.constBegin(), itRecEnd = allConList.constEnd(); itRec != itRecEnd; ++itRec) {
TConceptNegationPair succConNegPair(*itRec);
CConcept* succConcept = succConNegPair.first;
bool succConNegation = succConNegPair.second;
CNominalSchemaAbsorptionBranchLinker* newBranchLinker = getAbsorbedNominalSchemaBranchLinker(succConcept,succConNegation,activationTriggerConcept,nomSchConceptVariableHash,nsTemplate);
if (newBranchLinker && newBranchLinker->hasNext()) {
newMultiBranchConList.append(newBranchLinker);
} else if (newBranchLinker) {
newSingleBranchConList.append(newBranchLinker);
}
}
newBranchConList.append(newSingleBranchConList);
newBranchConList.append(newMultiBranchConList);
QList newBranchConItList;
for (QList::const_iterator it = newBranchConList.constBegin(), branchConListItEnd = newBranchConList.constEnd(); it != branchConListItEnd; ++it) {
newBranchConItList.append(*it);
}
QList orNewBranchConItList(newBranchConItList);
QList< CNominalSchemaAbsorptionBranchLinker* >::iterator nextChangeEndIt = newBranchConItList.end();
bool iterationFinished = false;
while (!iterationFinished) {
QList aborpBranchList;
for (QList::const_iterator it = newBranchConItList.constBegin(), itEnd = newBranchConItList.constEnd(); it != itEnd; ++it) {
aborpBranchList.append(*it);
}
bool removedOne = true;
while (removedOne) {
removedOne = false;
QList::iterator it1 = aborpBranchList.begin();
QList::iterator it2 = it1;
QList::iterator itEnd = aborpBranchList.end();
for (; it1 != itEnd && !removedOne; ++it1) {
it2 = it1;
for (++it2; it2 != itEnd && !removedOne; ++it2) {
CNominalSchemaAbsorptionBranchLinker* abLinker1 = qMin(*it1,*it2);;
CNominalSchemaAbsorptionBranchLinker* abLinker2 = qMax(*it1,*it2);;
TAbsorptionBranchPair absBranchPair(abLinker1,abLinker2);
CNominalSchemaAbsorptionBranchLinker* newAbsBranchLinker = mAbsorptionBranchPairAbsorptionBranchHash.value(absBranchPair,nullptr);
if (newAbsBranchLinker) {
removedOne = true;
aborpBranchList.removeOne(abLinker1);
aborpBranchList.removeOne(abLinker2);
aborpBranchList.append(newAbsBranchLinker);
CConcept* joiningConcept = newAbsBranchLinker->getBackPropagationBranchTriggerConcept();
addConceptOperand(activationTriggerConcept,joiningConcept,false);
}
}
}
}
CNominalSchemaAbsorptionBranchLinker* nextAbLinker = aborpBranchList.takeFirst();
while (!aborpBranchList.isEmpty()) {
CNominalSchemaAbsorptionBranchLinker* abLinker = aborpBranchList.takeFirst();
CConcept* branchTrigger1 = nextAbLinker->getLastBranchTriggerConcept();
CConcept* branchTrigger2 = abLinker->getLastBranchTriggerConcept();
CConcept* newImpliedBranchTrigger = createVariableBindingPropagationTriggerConcept();
CConcept* joiningConcept = createVariableBindingPropagationJoiningConcept(branchTrigger1,branchTrigger2,newImpliedBranchTrigger);
addConceptOperand(activationTriggerConcept,joiningConcept,false);
CNominalSchemaAbsorptionBranchLinker* newTmpAbLinker = new CNominalSchemaAbsorptionBranchLinker();
newTmpAbLinker->joinNominalSchemaAbsorptionPathLinker(nextAbLinker,abLinker);
newTmpAbLinker->setLastBranchTriggerConcept(newImpliedBranchTrigger);
newTmpAbLinker->setBackPropagationBranchTriggerConcept(joiningConcept);
createJoiningConceptVariableList(joiningConcept,nextAbLinker,abLinker);
TAbsorptionBranchPair absBranchPair(qMin(nextAbLinker,abLinker),qMax(nextAbLinker,abLinker));
mAbsorptionBranchPairAbsorptionBranchHash.insert(absBranchPair,newTmpAbLinker);
nextAbLinker = newTmpAbLinker;
}
if (triggerConcept) {
CConcept* nextVariableBindTrigger = createVariableBindingPropagationTriggerConcept();
CConcept* varImplConcept = createVariableBindingPropagationImplicationTriggeredConcept(triggerConcept,nextVariableBindTrigger);
CNominalSchemaAbsorptionBranchLinker* newTmpAbLinker = new CNominalSchemaAbsorptionBranchLinker();
newTmpAbLinker->initNominalSchemaAbsorptionPathLinker(nextAbLinker);
addConceptOperand(nextAbLinker->getLastBranchTriggerConcept(),varImplConcept,false);
newTmpAbLinker->setLastBranchTriggerConcept(nextVariableBindTrigger);
newTmpAbLinker->setBackPropagationBranchTriggerConcept(activationTriggerConcept);
nextAbLinker = newTmpAbLinker;
}
newAbLinker = nextAbLinker->append(newAbLinker);
QList< CNominalSchemaAbsorptionBranchLinker* >::iterator nextChangeIt = newBranchConItList.begin();
QList< CNominalSchemaAbsorptionBranchLinker* >::iterator nextOriginalIt = orNewBranchConItList.begin();
CNominalSchemaAbsorptionBranchLinker* nomSchAbsBranchLinkerIt = *nextChangeIt;
nomSchAbsBranchLinkerIt = nomSchAbsBranchLinkerIt->getNext();
bool continueIteration = true;
while (!nomSchAbsBranchLinkerIt && !iterationFinished) {
continueIteration = false;
*nextChangeIt = *nextOriginalIt;
++nextChangeIt;
++nextOriginalIt;
if (nextChangeIt == nextChangeEndIt) {
iterationFinished = true;
} else {
nomSchAbsBranchLinkerIt = *nextChangeIt;
nomSchAbsBranchLinkerIt = nomSchAbsBranchLinkerIt->getNext();
if (!nomSchAbsBranchLinkerIt) {
continueIteration = true;
}
}
}
if (!iterationFinished) {
*nextChangeIt = nomSchAbsBranchLinkerIt;
}
}
return newAbLinker;
}
CNominalSchemaAbsorptionBranchLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedNominalSchemaBranchLinker(CConcept* absorbingConcept, bool absorbingNegation, CConcept* backPropConTrigger, QHash* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
CNominalSchemaAbsorptionBranchLinker* newBranchLinker = nullptr;
TConceptNegationPair absConNegPair(absorbingConcept,absorbingNegation);
newBranchLinker = mConceptNomSchAbsorpBranchLinkerHash.value(absConNegPair);
if (!newBranchLinker) {
cint64 absConOpCode = absorbingConcept->getOperatorCode();
cint64 param = absorbingConcept->getParameter();
if (!absorbingNegation && (absConOpCode == CCSOME || absConOpCode == CCATLEAST && param == 1) || absorbingNegation && (absConOpCode == CCALL || absConOpCode == CCATMOST && param == 0)) {
CRole* role = absorbingConcept->getRole();
bool succOpNegate = absConOpCode == CCALL;
if (absorbingConcept->getOperandList()) {
CConcept* nextAbsorptionBranchTriggerConcept = createBindingBackPropagationTriggerConcept();
CConcept* propagationPathTriggerConcept = createBindingBackPropagationToSuccessorConcept(nextAbsorptionBranchTriggerConcept,role);
addConceptOperand(backPropConTrigger,propagationPathTriggerConcept,false);
QSet operandConceptSet;
for (CSortedNegLinker* succOpConLinkerIt = absorbingConcept->getOperandList(); succOpConLinkerIt; succOpConLinkerIt = succOpConLinkerIt->getNext()) {
CConcept* succOpCon = succOpConLinkerIt->getData();
bool succOpConNeg = succOpConLinkerIt->isNegated() ^ succOpNegate;
operandConceptSet.insert(TConceptNegationPair(succOpCon,succOpConNeg));
}
CNominalSchemaAbsorptionBranchLinker* nextAbsorptionBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(operandConceptSet,nextAbsorptionBranchTriggerConcept,nomSchConceptVariableHash,nsTemplate);
for (CNominalSchemaAbsorptionBranchLinker* nextAbsorptionBranchLinkerIt = nextAbsorptionBranchLinker; nextAbsorptionBranchLinkerIt; nextAbsorptionBranchLinkerIt = nextAbsorptionBranchLinkerIt->getNext()) {
CNominalSchemaAbsorptionBranchLinker* tmpNewAbsBranchLinker = new CNominalSchemaAbsorptionBranchLinker();
tmpNewAbsBranchLinker->initNominalSchemaAbsorptionPathLinker(nextAbsorptionBranchLinkerIt);
tmpNewAbsBranchLinker->setBackPropagationBranchTriggerConcept(propagationPathTriggerConcept);
CConcept* nextVariableBindPropTriggerConcept = createVariableBindingPropagationTriggerConcept();
CConcept* propagationVariableBindPropConcept = createVariableBindingPropagationFromSuccessorConcept(nextVariableBindPropTriggerConcept,role);
CConcept* lastVariableBindPropTriggerConcept = tmpNewAbsBranchLinker->getLastBranchTriggerConcept();
addConceptOperand(lastVariableBindPropTriggerConcept,propagationVariableBindPropConcept,false);
tmpNewAbsBranchLinker->setLastBranchTriggerConcept(nextVariableBindPropTriggerConcept);
newBranchLinker = tmpNewAbsBranchLinker->append(newBranchLinker);
}
}
} else if (!absorbingNegation && (absConOpCode == CCOR) || absorbingNegation && (absConOpCode == CCAND)) {
for (CSortedNegLinker* opConLinkerIt = absorbingConcept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opCon = opConLinkerIt->getData();
bool opConNeg = opConLinkerIt->isNegated() ^ absorbingNegation;
CNominalSchemaAbsorptionBranchLinker* tmpNewAbsBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(opCon,opConNeg,backPropConTrigger,nomSchConceptVariableHash,nsTemplate);
newBranchLinker = tmpNewAbsBranchLinker->append(newBranchLinker);
}
} else if (!absorbingNegation && (absConOpCode == CCNOMVAR)) {
CVariable* variable = nomSchConceptVariableHash->value(absorbingConcept,nullptr);
if (!variable) {
variable = CObjectAllocator< CVariable >::allocateAndConstruct(mMemMan);
variable->initVariable(absorbingConcept,mNextVariableID++);
nomSchConceptVariableHash->insert(absorbingConcept,variable);
}
CConcept* varBindTriggerConcept = createVariableBindingPropagationTriggerConcept();
CConcept* bindVarConcept = createVariableBindingPropagationBindVariableConcept(varBindTriggerConcept,variable);
CNominalSchemaAbsorptionBranchLinker* newAbsBranchLinker = new CNominalSchemaAbsorptionBranchLinker();
newAbsBranchLinker->initNominalSchemaAbsorptionPathLinker(nullptr);
newAbsBranchLinker->setLastBranchTriggerConcept(varBindTriggerConcept);
newAbsBranchLinker->setBackPropagationBranchTriggerConcept(bindVarConcept);
newAbsBranchLinker->addVariable(variable);
if (!mConfNominalSchemaBackPropagation) {
CConcept* nominalTriggerConcept = mTBox->getIndividualTriggerConcept();
CConcept* tmpNextAbsorptionConcept = createBindingBackPropagationActivationTriggerConcept();
addConceptOperand(nominalTriggerConcept,tmpNextAbsorptionConcept,false);
addConceptOperand(tmpNextAbsorptionConcept,bindVarConcept,false);
} else {
addConceptOperand(backPropConTrigger,bindVarConcept,false);
}
newBranchLinker = newAbsBranchLinker;
}
mConceptNomSchAbsorpBranchLinkerHash.insert(absConNegPair,newBranchLinker);
} else {
for (CNominalSchemaAbsorptionBranchLinker* nextAbsorptionBranchLinkerIt = newBranchLinker; nextAbsorptionBranchLinkerIt; nextAbsorptionBranchLinkerIt = nextAbsorptionBranchLinkerIt->getNext()) {
addConceptOperand(backPropConTrigger,nextAbsorptionBranchLinkerIt->getBackPropagationBranchTriggerConcept(),false);
}
}
return newBranchLinker;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationBindVariableConcept(CConcept* followingConcept, CVariable* variable) {
CConcept* bindConcept = createNewConcept();
bindConcept->setOperatorCode(CCVARBINDVARIABLE);
bindConcept->setVariableLinker(CObjectAllocator< CSortedLinker >::allocateAndConstruct(mMemMan)->init(variable));
addConceptOperand(bindConcept,followingConcept,false);
return bindConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationActivationTriggerConcept() {
CConcept* triggConcept = createNewConcept();
triggConcept->setOperatorCode(CCBACKACTIVTRIG);
return triggConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationTriggerConcept() {
CConcept* triggConcept = createNewConcept();
triggConcept->setOperatorCode(CCVARPBACKTRIG);
return triggConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationToSuccessorConcept(CConcept* followingConcept, CRole* role) {
CConcept* succPropConcept = createNewConcept();
succPropConcept->setOperatorCode(CCVARPBACKALL);
succPropConcept->setRole(role);
addConceptOperand(succPropConcept,followingConcept,false);
return succPropConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationFromSuccessorConcept(CConcept* followingConcept, CRole* role) {
CRole* inverseRole = getInverseRole(role);
CConcept* succPropConcept = createNewConcept();
succPropConcept->setOperatorCode(CCVARBINDALL);
succPropConcept->setRole(inverseRole);
addConceptOperand(succPropConcept,followingConcept,false);
return succPropConcept;
}
bool CTriggeredImplicationBinaryAbsorberPreProcess::addBindingBackPropagationTriggeredToImplicationConcept(CConcept* implicationConcept, CConcept* triggeredConcept) {
CSortedNegLinker* lastOpConLinker = nullptr;
for (CSortedNegLinker* opConLinker = implicationConcept->getOperandList(); opConLinker; opConLinker = opConLinker->getNext()) {
lastOpConLinker = opConLinker;
if (lastOpConLinker->getData() == triggeredConcept) {
return false;
}
}
CSortedNegLinker* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon1->init(triggeredConcept,true);
lastOpConLinker->setNext(newBaseOpCon1);
implicationConcept->incOperandCount();
return true;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept) {
CConcept* implicationConcept = createNewConcept();
implicationConcept->setOperatorCode(CCBACKACTIVIMPL);
CSortedNegLinker* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon1->init(triggeredConcept,true);
CSortedNegLinker* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon2->init(impliedConcept,false,newBaseOpCon1);
implicationConcept->setOperandList(newBaseOpCon2);
implicationConcept->incOperandCount(2);
return implicationConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept) {
CConcept* implicationConcept = createNewConcept();
implicationConcept->setOperatorCode(CCVARBINDIMPL);
CSortedNegLinker* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon1->init(triggeredConcept,true);
CSortedNegLinker* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon2->init(impliedConcept,false,newBaseOpCon1);
implicationConcept->setOperandList(newBaseOpCon2);
implicationConcept->incOperandCount(2);
return implicationConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationTriggerConcept() {
CConcept* triggConcept = createNewConcept();
triggConcept->setOperatorCode(CCVARBINDTRIG);
return triggConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationJoiningConcept(CConcept* joinConcept1, CConcept* joinConcept2, CConcept* impliedConcept) {
CConcept* joiningConcept = createNewConcept();
joiningConcept->setOperatorCode(CCVARBINDJOIN);
CSortedNegLinker* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon1->init(joinConcept2,true);
CSortedNegLinker* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon2->init(joinConcept1,true,newBaseOpCon1);
CSortedNegLinker* newBaseOpCon3 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
newBaseOpCon3->init(impliedConcept,false,newBaseOpCon2);
joiningConcept->setOperandList(newBaseOpCon3);
joiningConcept->incOperandCount(3);
return joiningConcept;
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createJoiningConceptVariableList(CConcept* joiningConcept, CNominalSchemaAbsorptionBranchLinker* abLinker1, CNominalSchemaAbsorptionBranchLinker* abLinker2) {
QSet* varSet1 = abLinker1->getVariableSet();
QSet* varSet2 = abLinker2->getVariableSet();
CSortedLinker* varLinker = nullptr;
for (QSet::const_iterator it = varSet1->constBegin(), itEnd = varSet1->constEnd(); it != itEnd; ++it) {
if (varSet2->contains(*it)) {
CVariable* variable = *it;
CSortedLinker* tmpVarLinker = CObjectAllocator< CSortedLinker >::allocateAndConstruct(mMemMan);
tmpVarLinker->init(variable);
if (varLinker) {
varLinker = varLinker->insertNextSorted(tmpVarLinker);
} else {
varLinker = tmpVarLinker;
}
}
}
joiningConcept->setVariableLinker(varLinker);
}
void CTriggeredImplicationBinaryAbsorberPreProcess::createGCIPartialAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, const QList& absorbList) {
//CConceptRoleBranchingTrigger* branchTriggers = nullptr;
//for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
// TConceptNegationPair conNegPair(*it);
// CConcept* concept = conNegPair.first;
// bool negated = conNegPair.second;
// CConceptRoleBranchingTrigger* tmpBranchTrigger = getSimpleBranchTriggersForConcept(concept,!negated);
// if (tmpBranchTrigger) {
// branchTriggers = tmpBranchTrigger->append(branchTriggers);
// } else {
// CConceptRoleBranchingTrigger* tmpBranchTrigger = getBranchTiggers(getPartialTriggersForConcept(concept,!negated));
// branchTriggers = tmpBranchTrigger->append(branchTriggers);
// }
//}
CConceptTriggerLinker* partialImpliedTrigger = createPartialExtendedAbsorbedImpliedTrigger(absorbList);
CConcept* partialImpliedTriggerConcept = partialImpliedTrigger->getTriggerConcept();
addUnfoldingConceptForConcept(partialImpliedTriggerConcept,orConcept,negated);
CConceptRoleBranchingTrigger* branchTriggers = getSimpleBranchTriggersForConcept(partialImpliedTriggerConcept,true);
mBranchTriggVec->setData(orConcept->getConceptTag(),branchTriggers);
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList& absorbList, QList& candList) {
CConcept* impliedConcept = nullptr;
CConcept* implicationConcept = nullptr;
bool impliedNegation = false;
if (candList.isEmpty()) {
candList.append(absorbList.takeFirst());
}
CConceptTriggerLinker* triggers = nullptr;
for (QList::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept,!negated));
triggers = tmpTriggers->append(triggers);
}
CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,&implicationConcept);
impliedConcept = impliedConceptTrigger->getTriggerConcept();
if (candList.count() > 1) {
CConcept* orImpliedConcept = createImpliedConcept();
for (QList::const_iterator it = candList.constBegin(), itEnd = candList.constEnd(); it != itEnd; ++it) {
TConceptNegationPair conNegPair(*it);
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
addConceptToImplied(orImpliedConcept,concept,negated);
}
orImpliedConcept->setOperatorCode(CCOR);
addUnfoldingConceptForConcept(impliedConcept,orImpliedConcept,false);
if (mConfPartialDisjunctionsAbsorption) {
QList partialAbsorbableList;
partialAbsorbableList = getPartialAbsorbableDisjuncts(candList);
if (!partialAbsorbableList.isEmpty()) {
CConcept* partialImpliedTriggerConcept = createPartialExtendedAbsorbedImpliedTriggerCocnept(partialAbsorbableList);
CConceptRoleBranchingTrigger* branchTriggers = getSimpleBranchTriggersForConcept(partialImpliedTriggerConcept,true);
mBranchTriggVec->setData(impliedConcept->getConceptTag(),branchTriggers);
++mStatGCIAbsorptionPartialExtended;
}
}
} else {
TConceptNegationPair conNegPair(candList.first());
CConcept* concept = conNegPair.first;
bool negated = conNegPair.second;
addUnfoldingConceptForConcept(impliedConcept,concept,negated);
}
return implicationConcept;
}
CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getRoleDomainTriggerConcept(CRole* role) {
if (!mRoleDomainTriggerConceptHash) {
mRoleDomainTriggerConceptHash = mTBox->getRoleDomainTriggerConceptHash(true);
}
CConcept*& triggerConcept = (*mRoleDomainTriggerConceptHash)[role];
if (!triggerConcept) {
triggerConcept = createTriggerConcept();
addRoleDomainConcept(role,triggerConcept,false);
}
return triggerConcept;
}
CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getTriggersForConcept(CConcept* concept, bool negated, CConcept* backPropConcept) {
CConceptTriggerLinker* triggers = nullptr;
CConcept* backPropImpConcept = nullptr;
CConcept* backPropTriggerConcept = nullptr;
CConcept** backPropImpConceptPointer = nullptr;
bool branchTiggerCreation = false;
if (backPropConcept) {
branchTiggerCreation = true;
backPropImpConceptPointer = &backPropImpConcept;
}
TConceptNegationPair conNegPair(concept,negated);
triggers = mConceptTriggerLinkerHash.value(conNegPair);
if (triggers && backPropConcept) {
CConcept* backPropActivCon = mBackPropActivationConHash.value(conNegPair);
if (backPropActivCon) {
addUnfoldingConceptForConcept(backPropConcept, backPropActivCon, false);
}
}
if (!triggers) {
if (backPropConcept) {
backPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
addUnfoldingConceptForConcept(backPropConcept, backPropTriggerConcept, false);
}
cint64 opCode = concept->getOperatorCode();
cint64 parm = concept->getParameter();
cint64 opCount = concept->getOperandCount();
CRole* role = concept->getRole();
CSortedNegLinker* opConLinker = concept->getOperandList();
if (!negated && (opCode == CCATOM || opCode == CCSUB || opCode == CCTOP || opCode == CCIMPLTRIG)) {
CConceptTriggerLinker* newTrigger = createTriggerLinker();
newTrigger->initConceptTriggerLinker(concept, 1);
if (backPropConcept) {
CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(newTrigger, backPropImpConceptPointer);
addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
newTrigger = implTriggeredConcept;
}
triggers = newTrigger->append(triggers);
} else if (negated && (opCode == CCOR) || !negated && (opCode == CCAND || opCode == CCEQ)) {
// AND, collect triggers from operands
CConceptTriggerLinker* andTriggers = nullptr;
for (CSortedNegLinker* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated()^negated;
CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getTriggersForConcept(opConcept,opNegated, backPropTriggerConcept));
andTriggers = newTriggers->append(andTriggers);
}
if (backPropConcept) {
CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(andTriggers, &backPropImpConcept);
addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
andTriggers = implTriggeredConcept;
}
triggers = andTriggers->append(triggers);
} else if (opCode == CCAQCHOOCE) {
CConceptTriggerLinker* andTriggers = nullptr;
for (CSortedNegLinker* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opConcept = opConLinkerIt->getData();
bool opNegated = opConLinkerIt->isNegated() ^ negated;
if (opNegated == negated) {
CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getTriggersForConcept(opConcept, opNegated, backPropTriggerConcept));
andTriggers = newTriggers->append(andTriggers);
}
}
if (backPropConcept) {
CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(andTriggers, &backPropImpConcept);
addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
andTriggers = implTriggeredConcept;
}
triggers = andTriggers->append(triggers);
} else if (!negated && (opCode == CCOR) || negated && (opCode == CCAND || opCode == CCEQ)) {
// or trigger
CConceptTriggerLinker* orTriggers = nullptr;
for (CSortedNegLinker